diff --git a/.gitignore b/.gitignore
index 70384df..b6cec0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 .DS_Store
 .gclient
 .gclient_entries
+.gclient_previous_sync_commits
 .vs
 .vscode/*
 !.vscode/tasks.json
@@ -10,10 +11,12 @@
 default.profraw
 lcov.info
 
-/buildtools
+/build/
+/buildtools/
 /cmake-build-*/
 /out
 /testing
+/third_party/abseil-cpp
 /third_party/benchmark
 /third_party/binutils
 /third_party/catapult
@@ -28,5 +31,4 @@
 /tools/clang
 /tools/bin
 
-/build*/
 /test.wgsl
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 615a71b..a2130e3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -77,6 +77,7 @@
 option_if_not_defined(TINT_BUILD_MSL_WRITER "Build the MSL output writer" ON)
 option_if_not_defined(TINT_BUILD_SPV_WRITER "Build the SPIR-V output writer" ON)
 option_if_not_defined(TINT_BUILD_WGSL_WRITER "Build the WGSL output writer" ON)
+option_if_not_defined(TINT_BUILD_SYNTAX_TREE_WRITER "Build the syntax tree writer" OFF)
 
 option_if_not_defined(TINT_BUILD_IR "Build the IR" ON)
 
@@ -113,6 +114,7 @@
 message(STATUS "Tint build MSL writer: ${TINT_BUILD_MSL_WRITER}")
 message(STATUS "Tint build SPIR-V writer: ${TINT_BUILD_SPV_WRITER}")
 message(STATUS "Tint build WGSL writer: ${TINT_BUILD_WGSL_WRITER}")
+message(STATUS "Tint build Syntax Tree writer: ${TINT_BUILD_SYNTAX_TREE_WRITER}")
 message(STATUS "Tint build IR: ${TINT_BUILD_IR}")
 message(STATUS "Tint build fuzzers: ${TINT_BUILD_FUZZERS}")
 message(STATUS "Tint build SPIRV-Tools fuzzer: ${TINT_BUILD_SPIRV_TOOLS_FUZZER}")
@@ -284,6 +286,7 @@
   target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_MSL_WRITER=$<BOOL:${TINT_BUILD_MSL_WRITER}>)
   target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_SPV_WRITER=$<BOOL:${TINT_BUILD_SPV_WRITER}>)
   target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_WGSL_WRITER=$<BOOL:${TINT_BUILD_WGSL_WRITER}>)
+  target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_SYNTAX_TREE_WRITER=$<BOOL:${TINT_BUILD_SYNTAX_TREE_WRITER}>)
   target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_IR=$<BOOL:${TINT_BUILD_IR}>)
 
   if (COMPILER_IS_LIKE_GNU)
diff --git a/DEPS b/DEPS
index 007996b..3c1a058 100644
--- a/DEPS
+++ b/DEPS
@@ -85,6 +85,10 @@
     'dep_type': 'cipd',
   },
 
+  'third_party/abseil-cpp': {
+    'url': '{chromium_git}/chromium/src/third_party/abseil-cpp@bc3ab29356a081d0b5dd4ac55e30f4b45d8794cc',
+  },
+
   # Dependencies required for testing
   'testing': {
     'url': '{chromium_git}/chromium/src/testing@d5ea1bf4b64781cfe38f207f56f264eb080d06b2',
diff --git a/build_overrides/dawn.gni b/build_overrides/dawn.gni
new file mode 100644
index 0000000..6440625
--- /dev/null
+++ b/build_overrides/dawn.gni
@@ -0,0 +1,43 @@
+# Copyright 2018 The Dawn Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# These are variables that are overridable by projects that include Dawn.
+# The values in this file are the defaults for when we are building from
+# Dawn's repository.
+
+# Whether we are building from Dawn's repository.
+# MUST be unset in other projects (will default to false).
+dawn_standalone = true
+
+# True if Dawn can access build/, testing/ and other Chrome folders.
+dawn_has_build = true
+
+# Defaults for these are set again in dawn_overrides_with_defaults.gni so that
+# users of Dawn don't have to set dirs if they happen to use the same as Dawn.
+
+# The paths to Dawn's dependencies
+dawn_abseil_dir = "//third_party/abseil-cpp"
+dawn_angle_dir = "//third_party/angle"
+dawn_jinja2_dir = "//third_party/jinja2"
+dawn_glfw_dir = "//third_party/glfw"
+dawn_googletest_dir = "//third_party/googletest"
+dawn_spirv_tools_dir = "//third_party/vulkan-deps/spirv-tools/src"
+dawn_swiftshader_dir = "//third_party/swiftshader"
+dawn_vulkan_loader_dir = "//third_party/vulkan-deps/vulkan-loader/src"
+dawn_vulkan_validation_layers_dir =
+    "//third_party/vulkan-deps/vulkan-validation-layers/src"
+
+# Optional path to a one-liner version file. Default is empty path indicating
+# that git should be used to figure out the version.
+dawn_version_file = ""
diff --git a/include/tint/tint.h b/include/tint/tint.h
index 758e62a..0a0c027 100644
--- a/include/tint/tint.h
+++ b/include/tint/tint.h
@@ -27,7 +27,6 @@
 #include "src/tint/reader/reader.h"
 #include "src/tint/text/unicode.h"
 #include "src/tint/transform/binding_remapper.h"
-#include "src/tint/transform/clamp_frag_depth.h"
 #include "src/tint/transform/first_index_offset.h"
 #include "src/tint/transform/manager.h"
 #include "src/tint/transform/multiplanar_external_texture.h"
@@ -36,6 +35,8 @@
 #include "src/tint/transform/substitute_override.h"
 #include "src/tint/transform/vertex_pulling.h"
 #include "src/tint/type/manager.h"
+#include "src/tint/writer/array_length_from_uniform_options.h"
+#include "src/tint/writer/binding_point.h"
 #include "src/tint/writer/flatten_bindings.h"
 #include "src/tint/writer/writer.h"
 
diff --git a/scripts/dawn_overrides_with_defaults.gni b/scripts/dawn_overrides_with_defaults.gni
new file mode 100644
index 0000000..bbe79e1
--- /dev/null
+++ b/scripts/dawn_overrides_with_defaults.gni
@@ -0,0 +1,91 @@
+# Copyright 2018 The Dawn Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This files imports the overrides for Dawn but sets the defaults so that
+# projects including Dawn don't have to set dirs if they happen to use the
+# same.
+# It takes advantage of GN's variable scoping rules to define global variables
+# inside if constructs.
+
+import("//build_overrides/dawn.gni")
+
+if (!defined(dawn_standalone)) {
+  dawn_standalone = false
+}
+
+if (!defined(dawn_has_build)) {
+  dawn_has_build = true
+}
+
+if (!defined(dawn_root)) {
+  dawn_root = get_path_info("..", "abspath")
+}
+dawn_gen_root = get_path_info("${dawn_root}", "gen_dir")
+
+if (!defined(dawn_jinja2_dir)) {
+  dawn_jinja2_dir = "//third_party/jinja2"
+}
+
+if (!defined(dawn_glfw_dir)) {
+  dawn_glfw_dir = "//third_party/glfw"
+}
+
+if (!defined(dawn_googletest_dir)) {
+  dawn_googletest_dir = "//third_party/googletest"
+}
+
+if (!defined(dawn_spirv_tools_dir)) {
+  dawn_spirv_tools_dir = "//third_party/vulkan-deps/spirv-tools/src"
+}
+
+if (!defined(dawn_swiftshader_dir)) {
+  # Default to swiftshader not being available.
+  dawn_swiftshader_dir = ""
+}
+
+if (!defined(dawn_vulkan_deps_dir)) {
+  dawn_vulkan_deps_dir = "//third_party/vulkan-deps"
+  if (dawn_standalone) {
+    dawn_vulkan_deps_dir = "${dawn_root}/third_party/vulkan-deps"
+  }
+}
+
+if (!defined(dawn_vulkan_headers_dir)) {
+  dawn_vulkan_headers_dir = "${dawn_vulkan_deps_dir}/vulkan-headers/src"
+}
+
+if (!defined(dawn_vulkan_loader_dir)) {
+  # Default to the Vulkan loader not being available except in standalone.
+  dawn_vulkan_loader_dir = ""
+  if (dawn_standalone) {
+    dawn_vulkan_loader_dir = "//third_party/vulkan-deps/vulkan-loader/src"
+  }
+}
+
+if (!defined(dawn_vulkan_tools_dir)) {
+  dawn_vulkan_tools_dir = "${dawn_vulkan_deps_dir}/vulkan-tools/src"
+}
+
+if (!defined(dawn_vulkan_validation_layers_dir)) {
+  # Default to VVLs not being available.
+  dawn_vulkan_validation_layers_dir = ""
+}
+
+if (!defined(dawn_abseil_dir)) {
+  dawn_abseil_dir = "//third_party/abseil-cpp"
+}
+
+if (!defined(dawn_version_file)) {
+  dawn_version_file = ""
+}
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 89eb6ee..11d98bd 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -14,6 +14,7 @@
 
 import("//build_overrides/build.gni")
 
+import("../../scripts/dawn_overrides_with_defaults.gni")
 import("../../tint_overrides_with_defaults.gni")
 
 if (tint_build_unittests) {
@@ -78,6 +79,12 @@
     defines += [ "TINT_BUILD_GLSL_WRITER=0" ]
   }
 
+  if (tint_build_syntax_tree_writer) {
+    defines += [ "TINT_BUILD_SYNTAX_TREE_WRITER=1" ]
+  } else {
+    defines += [ "TINT_BUILD_SYNTAX_TREE_WRITER=0" ]
+  }
+
   include_dirs = [
     "${tint_root_dir}/",
     "${tint_root_dir}/include/",
@@ -92,6 +99,17 @@
   }
 }
 
+group("abseil") {
+  # When build_with_chromium=true we need to include "//third_party/abseil-cpp:absl" while
+  # it's beneficial to be more specific with standalone Dawn, especially when it comes to
+  # including it as a dependency in other projects (such as Skia).
+  if (build_with_chromium) {
+    public_deps = [ "$dawn_abseil_dir:absl" ]
+  } else {
+    public_deps = [ "${dawn_root}/third_party/gn/abseil-cpp:strings" ]
+  }
+}
+
 ###############################################################################
 # Helper library for IO operations
 # Only to be used by tests and sample executable
@@ -195,6 +213,7 @@
     "scope_stack.h",
     "source.cc",
     "source.h",
+    "switch.h",
     "symbol.cc",
     "symbol.h",
     "symbol_table.cc",
@@ -476,6 +495,7 @@
     "ast/discard_statement.h",
     "ast/enable.h",
     "ast/expression.h",
+    "ast/extension.h",
     "ast/float_literal_expression.h",
     "ast/for_loop_statement.h",
     "ast/function.h",
@@ -562,6 +582,7 @@
     "ast/discard_statement.cc",
     "ast/enable.cc",
     "ast/expression.cc",
+    "ast/extension.cc",
     "ast/float_literal_expression.cc",
     "ast/for_loop_statement.cc",
     "ast/function.cc",
@@ -633,8 +654,6 @@
     "sem/builtin.h",
     "sem/builtin_enum_expression.cc",
     "sem/builtin_enum_expression.h",
-    "sem/builtin_type.cc",
-    "sem/builtin_type.h",
     "sem/call.cc",
     "sem/call.h",
     "sem/call_target.cc",
@@ -642,6 +661,7 @@
     "sem/evaluation_stage.h",
     "sem/expression.cc",
     "sem/expression.h",
+    "sem/external_texture.h",
     "sem/for_loop_statement.cc",
     "sem/for_loop_statement.h",
     "sem/function.cc",
@@ -718,6 +738,8 @@
     "builtin/diagnostic_severity.h",
     "builtin/extension.cc",
     "builtin/extension.h",
+    "builtin/function.cc",
+    "builtin/function.h",
     "builtin/interpolation_sampling.cc",
     "builtin/interpolation_sampling.h",
     "builtin/interpolation_type.cc",
@@ -877,14 +899,15 @@
     "writer/append_vector.h",
     "writer/array_length_from_uniform_options.cc",
     "writer/array_length_from_uniform_options.h",
+    "writer/binding_point.h",
     "writer/check_supported_extensions.cc",
     "writer/check_supported_extensions.h",
+    "writer/external_texture_options.cc",
+    "writer/external_texture_options.h",
     "writer/flatten_bindings.cc",
     "writer/flatten_bindings.h",
     "writer/float_to_string.cc",
     "writer/float_to_string.h",
-    "writer/generate_external_texture_bindings.cc",
-    "writer/generate_external_texture_bindings.h",
     "writer/text.cc",
     "writer/text.h",
     "writer/text_generator.cc",
@@ -953,6 +976,7 @@
   ]
 
   deps = [
+    ":abseil",
     ":libtint_ast_src",
     ":libtint_base_src",
     ":libtint_builtins_src",
@@ -1045,6 +1069,25 @@
   ]
 }
 
+libtint_source_set("libtint_syntax_tree_writer_src") {
+  sources = [
+    "writer/syntax_tree/generator.cc",
+    "writer/syntax_tree/generator.h",
+    "writer/syntax_tree/generator_impl.cc",
+    "writer/syntax_tree/generator_impl.h",
+  ]
+
+  deps = [
+    ":libtint_ast_src",
+    ":libtint_base_src",
+    ":libtint_builtins_src",
+    ":libtint_program_src",
+    ":libtint_sem_src",
+    ":libtint_type_src",
+    ":libtint_writer_src",
+  ]
+}
+
 source_set("libtint") {
   public_deps = [
     ":libtint_ast_src",
@@ -1089,6 +1132,10 @@
     public_deps += [ ":libtint_glsl_writer_src" ]
   }
 
+  if (tint_build_syntax_tree_writer) {
+    public_deps += [ ":libtint_syntax_tree_writer_src" ]
+  }
+
   configs += [ ":tint_common_config" ]
   public_configs = [ ":tint_public_config" ]
 
@@ -1580,7 +1627,6 @@
       "writer/check_supported_extensions_test.cc",
       "writer/flatten_bindings_test.cc",
       "writer/float_to_string_test.cc",
-      "writer/generate_external_texture_bindings_test.cc",
       "writer/text_generator_test.cc",
     ]
     deps = [
@@ -1590,6 +1636,16 @@
     ]
   }
 
+  # Note, this includes the source files along with the test as otherwise the cmd helpers wouldn't
+  # be included in the binary.
+  tint_unittests_source_set("tint_unittests_cmd_src") {
+    sources = [
+      "cmd/generate_external_texture_bindings.cc",
+      "cmd/generate_external_texture_bindings.h",
+      "cmd/generate_external_texture_bindings_test.cc",
+    ]
+  }
+
   tint_unittests_source_set("tint_unittests_spv_reader_src") {
     sources = [
       "reader/spirv/enum_converter_test.cc",
@@ -1939,6 +1995,7 @@
       "reflection_test.cc",
       "scope_stack_test.cc",
       "source_test.cc",
+      "switch_test.cc",
       "symbol_table_test.cc",
       "symbol_test.cc",
       "traits_test.cc",
@@ -1985,6 +2042,7 @@
       ":tint_unittests_ast_src",
       ":tint_unittests_base_src",
       ":tint_unittests_builtins_src",
+      ":tint_unittests_cmd_src",
       ":tint_unittests_constant_src",
       ":tint_unittests_core_src",
       ":tint_unittests_demangler_src",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 1d31896..07f7aa8 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -134,6 +134,8 @@
   ast/enable.h
   ast/expression.cc
   ast/expression.h
+  ast/extension.cc
+  ast/extension.h
   ast/float_literal_expression.cc
   ast/float_literal_expression.h
   ast/for_loop_statement.cc
@@ -280,6 +282,7 @@
   resolver/validator.cc
   resolver/validator.h
   scope_stack.h
+  switch.h
   sem/array_count.cc
   sem/array_count.h
   sem/behavior.cc
@@ -300,6 +303,7 @@
   sem/evaluation_stage.h
   sem/expression.cc
   sem/expression.h
+  sem/external_texture.h
   sem/for_loop_statement.cc
   sem/for_loop_statement.h
   sem/function_expression.cc
@@ -539,14 +543,15 @@
   writer/append_vector.h
   writer/array_length_from_uniform_options.cc
   writer/array_length_from_uniform_options.h
+  writer/binding_point.h
   writer/check_supported_extensions.cc
   writer/check_supported_extensions.h
+  writer/external_texture_options.cc
+  writer/external_texture_options.h
   writer/flatten_bindings.cc
   writer/flatten_bindings.h
   writer/float_to_string.cc
   writer/float_to_string.h
-  writer/generate_external_texture_bindings.cc
-  writer/generate_external_texture_bindings.h
   writer/text_generator.cc
   writer/text_generator.h
   writer/text.cc
@@ -563,12 +568,12 @@
 tint_generated(builtin/diagnostic_rule BENCH TEST)
 tint_generated(builtin/diagnostic_severity BENCH TEST)
 tint_generated(builtin/extension BENCH TEST)
+tint_generated(builtin/function)
 tint_generated(builtin/interpolation_sampling BENCH TEST)
 tint_generated(builtin/interpolation_type BENCH TEST)
 tint_generated(builtin/texel_format BENCH TEST)
 
 tint_generated(resolver/ctor_conv_intrinsic)
-tint_generated(sem/builtin_type)
 tint_generated(sem/parameter_usage)
 
 if(UNIX)
@@ -677,6 +682,15 @@
   )
 endif()
 
+if(${TINT_BUILD_SYNTAX_TREE_WRITER})
+    list(APPEND TINT_LIB_SRCS
+      writer/syntax_tree/generator.cc
+      writer/syntax_tree/generator.h
+      writer/syntax_tree/generator_impl.cc
+      writer/syntax_tree/generator_impl.h
+    )
+endif()
+
 if(${TINT_BUILD_IR})
   list(APPEND TINT_LIB_SRCS
     ir/binary.cc
@@ -689,8 +703,16 @@
     ir/builder.h
     ir/builder_impl.cc
     ir/builder_impl.h
+    ir/builtin.cc
+    ir/builtin.h
+    ir/call.cc
+    ir/call.h
     ir/constant.cc
     ir/constant.h
+    ir/construct.cc
+    ir/construct.h
+    ir/convert.cc
+    ir/convert.h
     ir/debug.cc
     ir/debug.h
     ir/disassembler.cc
@@ -713,6 +735,8 @@
     ir/temp.h
     ir/terminator.cc
     ir/terminator.h
+    ir/user_call.cc
+    ir/user_call.h
     ir/value.cc
     ir/value.h
   )
@@ -760,7 +784,7 @@
 ## Tint library
 add_library(libtint ${TINT_LIB_SRCS})
 tint_default_compile_options(libtint)
-target_link_libraries(libtint tint_diagnostic_utils)
+target_link_libraries(libtint tint_diagnostic_utils absl_strings)
 if (${TINT_SYMBOL_STORE_DEBUG_NAME})
     target_compile_definitions(libtint PUBLIC "TINT_SYMBOL_STORE_DEBUG_NAME=1")
 endif()
@@ -770,7 +794,7 @@
   # Tint library with fuzzer instrumentation
   add_library(libtint-fuzz ${TINT_LIB_SRCS})
   tint_default_compile_options(libtint-fuzz)
-  target_link_libraries(libtint-fuzz tint_diagnostic_utils)
+  target_link_libraries(libtint-fuzz tint_diagnostic_utils absl_strings)
   if (${COMPILER_IS_LIKE_GNU})
     target_compile_options(libtint-fuzz PRIVATE -fvisibility=hidden)
   endif()
@@ -942,6 +966,7 @@
     sem/struct_test.cc
     sem/value_expression_test.cc
     source_test.cc
+    switch_test.cc
     symbol_table_test.cc
     symbol_test.cc
     test_main.cc
@@ -997,10 +1022,17 @@
     writer/check_supported_extensions_test.cc
     writer/flatten_bindings_test.cc
     writer/float_to_string_test.cc
-    writer/generate_external_texture_bindings_test.cc
     writer/text_generator_test.cc
   )
 
+  # Noet, the source files are included here otherwise the cmd sources would not be included in the
+  # test binary.
+  list(APPEND TINT_TEST_SRCS
+    cmd/generate_external_texture_bindings.cc
+    cmd/generate_external_texture_bindings.h
+    cmd/generate_external_texture_bindings_test.cc
+  )
+
   # Uniformity analysis tests depend on WGSL reader
   if(${TINT_BUILD_WGSL_READER})
     list(APPEND TINT_TEST_SRCS
@@ -1437,7 +1469,7 @@
   endif()
 
   list(APPEND TINT_BENCHMARK_SRCS
-    "castable_bench.cc"
+    "switch_bench.cc"
     "bench/benchmark.cc"
     "reader/wgsl/parser_bench.cc"
   )
diff --git a/src/tint/ast/builtin_texture_helper_test.cc b/src/tint/ast/builtin_texture_helper_test.cc
index 6d6aa69..658b650 100644
--- a/src/tint/ast/builtin_texture_helper_test.cc
+++ b/src/tint/ast/builtin_texture_helper_test.cc
@@ -852,6 +852,17 @@
             /* returns value */ true,
         },
         {
+            ValidTextureOverload::kNumLayersCubeArray,
+            "textureNumLayers(t : texture_cube_array<f32>) -> u32",
+            TextureKind::kRegular,
+            type::SamplerKind::kSampler,
+            type::TextureDimension::kCubeArray,
+            TextureDataType::kF32,
+            "textureNumLayers",
+            [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
+            /* returns value */ true,
+        },
+        {
             ValidTextureOverload::kNumLayersDepth2dArray,
             "textureNumLayers(t : texture_depth_2d_array) -> u32",
             TextureKind::kDepth,
@@ -863,6 +874,17 @@
             /* returns value */ true,
         },
         {
+            ValidTextureOverload::kNumLayersDepthCubeArray,
+            "textureNumLayers(t : texture_depth_cube_array) -> u32",
+            TextureKind::kDepth,
+            type::SamplerKind::kSampler,
+            type::TextureDimension::kCubeArray,
+            TextureDataType::kF32,
+            "textureNumLayers",
+            [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
+            /* returns value */ true,
+        },
+        {
             ValidTextureOverload::kNumLayersStorageWO2dArray,
             "textureNumLayers(t : texture_storage_2d_array<rgba32float>) -> u32",
             tint::builtin::Access::kWrite,
diff --git a/src/tint/ast/builtin_texture_helper_test.h b/src/tint/ast/builtin_texture_helper_test.h
index 4e1e46f..738db0c 100644
--- a/src/tint/ast/builtin_texture_helper_test.h
+++ b/src/tint/ast/builtin_texture_helper_test.h
@@ -83,7 +83,9 @@
     kGatherCompareDepthCubeF32,
     kGatherCompareDepthCubeArrayF32,
     kNumLayers2dArray,
+    kNumLayersCubeArray,
     kNumLayersDepth2dArray,
+    kNumLayersDepthCubeArray,
     kNumLayersStorageWO2dArray,
     kNumLevels2d,
     kNumLevels2dArray,
diff --git a/src/tint/ast/enable.cc b/src/tint/ast/enable.cc
index 6087a3e..bb2b3b6 100644
--- a/src/tint/ast/enable.cc
+++ b/src/tint/ast/enable.cc
@@ -20,15 +20,29 @@
 
 namespace tint::ast {
 
-Enable::Enable(ProgramID pid, NodeID nid, const Source& src, builtin::Extension ext)
-    : Base(pid, nid, src), extension(ext) {}
+Enable::Enable(ProgramID pid,
+               NodeID nid,
+               const Source& src,
+               utils::VectorRef<const Extension*> exts)
+    : Base(pid, nid, src), extensions(std::move(exts)) {}
 
 Enable::Enable(Enable&&) = default;
 
 Enable::~Enable() = default;
 
+bool Enable::HasExtension(builtin::Extension ext) const {
+    for (auto* e : extensions) {
+        if (e->name == ext) {
+            return true;
+        }
+    }
+    return false;
+}
+
 const Enable* Enable::Clone(CloneContext* ctx) const {
     auto src = ctx->Clone(source);
-    return ctx->dst->create<Enable>(src, extension);
+    auto exts = ctx->Clone(extensions);
+    return ctx->dst->create<Enable>(src, std::move(exts));
 }
+
 }  // namespace tint::ast
diff --git a/src/tint/ast/enable.h b/src/tint/ast/enable.h
index 0c64df9..d87d12f 100644
--- a/src/tint/ast/enable.h
+++ b/src/tint/ast/enable.h
@@ -19,8 +19,7 @@
 #include <utility>
 #include <vector>
 
-#include "src/tint/ast/node.h"
-#include "src/tint/builtin/extension.h"
+#include "src/tint/ast/extension.h"
 
 namespace tint::ast {
 
@@ -35,21 +34,24 @@
     /// @param pid the identifier of the program that owns this node
     /// @param nid the unique node identifier
     /// @param src the source of this node
-    /// @param ext the extension
-    Enable(ProgramID pid, NodeID nid, const Source& src, builtin::Extension ext);
+    /// @param exts the extensions being enabled by this directive
+    Enable(ProgramID pid, NodeID nid, const Source& src, utils::VectorRef<const Extension*> exts);
     /// Move constructor
     Enable(Enable&&);
 
     ~Enable() override;
 
-    /// Clones this node and all transitive child nodes using the `CloneContext`
-    /// `ctx`.
+    /// @param ext the extension to search for
+    /// @returns true if this Enable lists the given extension
+    bool HasExtension(builtin::Extension ext) const;
+
+    /// Clones this node and all transitive child nodes using the `CloneContext` `ctx`.
     /// @param ctx the clone context
     /// @return the newly cloned node
     const Enable* Clone(CloneContext* ctx) const override;
 
-    /// The extension name
-    const builtin::Extension extension;
+    /// The extensions being enabled by this directive
+    const utils::Vector<const Extension*, 4> extensions;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/enable_test.cc b/src/tint/ast/enable_test.cc
index 5622207..20105bc 100644
--- a/src/tint/ast/enable_test.cc
+++ b/src/tint/ast/enable_test.cc
@@ -27,7 +27,14 @@
     EXPECT_EQ(ext->source.range.begin.column, 2u);
     EXPECT_EQ(ext->source.range.end.line, 20u);
     EXPECT_EQ(ext->source.range.end.column, 5u);
-    EXPECT_EQ(ext->extension, builtin::Extension::kF16);
+    ASSERT_EQ(ext->extensions.Length(), 1u);
+    EXPECT_EQ(ext->extensions[0]->name, builtin::Extension::kF16);
+}
+
+TEST_F(EnableTest, HasExtension) {
+    auto* ext = Enable(Source{{{20, 2}, {20, 5}}}, builtin::Extension::kF16);
+    EXPECT_TRUE(ext->HasExtension(builtin::Extension::kF16));
+    EXPECT_FALSE(ext->HasExtension(builtin::Extension::kChromiumDisableUniformityAnalysis));
 }
 
 }  // namespace
diff --git a/src/tint/ast/extension.cc b/src/tint/ast/extension.cc
new file mode 100644
index 0000000..a45c704
--- /dev/null
+++ b/src/tint/ast/extension.cc
@@ -0,0 +1,40 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ast/extension.h"
+
+#include "src/tint/program_builder.h"
+
+//! @cond Doxygen_Suppress
+// Doxygen gets confused with tint::ast::Extension and tint::builtin::Extension
+
+TINT_INSTANTIATE_TYPEINFO(tint::ast::Extension);
+
+namespace tint::ast {
+
+Extension::Extension(ProgramID pid, NodeID nid, const Source& src, builtin::Extension ext)
+    : Base(pid, nid, src), name(ext) {}
+
+Extension::Extension(Extension&&) = default;
+
+Extension::~Extension() = default;
+
+const Extension* Extension::Clone(CloneContext* ctx) const {
+    auto src = ctx->Clone(source);
+    return ctx->dst->create<Extension>(src, name);
+}
+
+}  // namespace tint::ast
+
+//! @endcond
diff --git a/src/tint/ast/extension.h b/src/tint/ast/extension.h
new file mode 100644
index 0000000..93f3baa
--- /dev/null
+++ b/src/tint/ast/extension.h
@@ -0,0 +1,52 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_AST_EXTENSION_H_
+#define SRC_TINT_AST_EXTENSION_H_
+
+#include "src/tint/ast/node.h"
+#include "src/tint/builtin/extension.h"
+
+namespace tint::ast {
+
+/// An extension used in an "enable" directive. Example:
+/// ```
+///   enable f16;
+/// ```
+class Extension final : public Castable<Extension, Node> {
+  public:
+    /// Create a extension
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
+    /// @param src the source of this node
+    /// @param ext the extension
+    Extension(ProgramID pid, NodeID nid, const Source& src, builtin::Extension ext);
+    /// Move constructor
+    Extension(Extension&&);
+
+    ~Extension() override;
+
+    /// Clones this node and all transitive child nodes using the `CloneContext`
+    /// `ctx`.
+    /// @param ctx the clone context
+    /// @return the newly cloned node
+    const Extension* Clone(CloneContext* ctx) const override;
+
+    /// The extension name
+    const builtin::Extension name;
+};
+
+}  // namespace tint::ast
+
+#endif  // SRC_TINT_AST_EXTENSION_H_
diff --git a/src/tint/ast/for_loop_statement.cc b/src/tint/ast/for_loop_statement.cc
index aba956d..b2a5470 100644
--- a/src/tint/ast/for_loop_statement.cc
+++ b/src/tint/ast/for_loop_statement.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/ast/for_loop_statement.h"
 
+#include <utility>
+
 #include "src/tint/program_builder.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ast::ForLoopStatement);
@@ -26,14 +28,24 @@
                                    const Statement* init,
                                    const Expression* cond,
                                    const Statement* cont,
-                                   const BlockStatement* b)
-    : Base(pid, nid, src), initializer(init), condition(cond), continuing(cont), body(b) {
+                                   const BlockStatement* b,
+                                   utils::VectorRef<const ast::Attribute*> attrs)
+    : Base(pid, nid, src),
+      initializer(init),
+      condition(cond),
+      continuing(cont),
+      body(b),
+      attributes(std::move(attrs)) {
     TINT_ASSERT(AST, body);
 
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, initializer, program_id);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, condition, program_id);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, continuing, program_id);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, body, program_id);
+    for (auto* attr : attributes) {
+        TINT_ASSERT(AST, attr);
+        TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, attr, program_id);
+    }
 }
 
 ForLoopStatement::ForLoopStatement(ForLoopStatement&&) = default;
@@ -48,7 +60,8 @@
     auto* cond = ctx->Clone(condition);
     auto* cont = ctx->Clone(continuing);
     auto* b = ctx->Clone(body);
-    return ctx->dst->create<ForLoopStatement>(src, init, cond, cont, b);
+    auto attrs = ctx->Clone(attributes);
+    return ctx->dst->create<ForLoopStatement>(src, init, cond, cont, b, std::move(attrs));
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/for_loop_statement.h b/src/tint/ast/for_loop_statement.h
index 59e0587..6063dda 100644
--- a/src/tint/ast/for_loop_statement.h
+++ b/src/tint/ast/for_loop_statement.h
@@ -32,13 +32,15 @@
     /// @param condition the optional loop condition expression
     /// @param continuing the optional continuing statement
     /// @param body the loop body
+    /// @param attributes the while statement attributes
     ForLoopStatement(ProgramID pid,
                      NodeID nid,
                      const Source& source,
                      const Statement* initializer,
                      const Expression* condition,
                      const Statement* continuing,
-                     const BlockStatement* body);
+                     const BlockStatement* body,
+                     utils::VectorRef<const ast::Attribute*> attributes);
     /// Move constructor
     ForLoopStatement(ForLoopStatement&&);
     ~ForLoopStatement() override;
@@ -60,6 +62,9 @@
 
     /// The loop body block
     const BlockStatement* const body;
+
+    /// The attribute list
+    const utils::Vector<const Attribute*, 1> attributes;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/for_loop_statement_test.cc b/src/tint/ast/for_loop_statement_test.cc
index 5e2a000..ad9050e 100644
--- a/src/tint/ast/for_loop_statement_test.cc
+++ b/src/tint/ast/for_loop_statement_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "src/tint/ast/binary_expression.h"
 #include "src/tint/ast/test_helper.h"
@@ -50,6 +51,15 @@
     EXPECT_EQ(l->body, body);
 }
 
+TEST_F(ForLoopStatementTest, Creation_WithAttributes) {
+    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "foo");
+    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "bar");
+    auto* body = Block(Return());
+    auto* l = For(nullptr, nullptr, nullptr, body, utils::Vector{attr1, attr2});
+
+    EXPECT_THAT(l->attributes, testing::ElementsAre(attr1, attr2));
+}
+
 TEST_F(ForLoopStatementTest, Assert_Null_Body) {
     EXPECT_FATAL_FAILURE(
         {
diff --git a/src/tint/ast/if_statement.cc b/src/tint/ast/if_statement.cc
index fdea1da..6878c9f 100644
--- a/src/tint/ast/if_statement.cc
+++ b/src/tint/ast/if_statement.cc
@@ -25,8 +25,13 @@
                          const Source& src,
                          const Expression* cond,
                          const BlockStatement* b,
-                         const Statement* else_stmt)
-    : Base(pid, nid, src), condition(cond), body(b), else_statement(else_stmt) {
+                         const Statement* else_stmt,
+                         utils::VectorRef<const Attribute*> attrs)
+    : Base(pid, nid, src),
+      condition(cond),
+      body(b),
+      else_statement(else_stmt),
+      attributes(std::move(attrs)) {
     TINT_ASSERT(AST, condition);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, condition, program_id);
     TINT_ASSERT(AST, body);
@@ -35,6 +40,10 @@
         TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, else_statement, program_id);
         TINT_ASSERT(AST, (else_statement->IsAnyOf<IfStatement, BlockStatement>()));
     }
+    for (auto* attr : attributes) {
+        TINT_ASSERT(AST, attr);
+        TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, attr, program_id);
+    }
 }
 
 IfStatement::IfStatement(IfStatement&&) = default;
@@ -47,7 +56,8 @@
     auto* cond = ctx->Clone(condition);
     auto* b = ctx->Clone(body);
     auto* el = ctx->Clone(else_statement);
-    return ctx->dst->create<IfStatement>(src, cond, b, el);
+    auto attrs = ctx->Clone(attributes);
+    return ctx->dst->create<IfStatement>(src, cond, b, el, std::move(attrs));
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/if_statement.h b/src/tint/ast/if_statement.h
index 1c1abc3..8f291a8 100644
--- a/src/tint/ast/if_statement.h
+++ b/src/tint/ast/if_statement.h
@@ -32,12 +32,14 @@
     /// @param condition the if condition
     /// @param body the if body
     /// @param else_stmt the else statement, or nullptr
+    /// @param attributes the if statement attributes
     IfStatement(ProgramID pid,
                 NodeID nid,
                 const Source& src,
                 const Expression* condition,
                 const BlockStatement* body,
-                const Statement* else_stmt);
+                const Statement* else_stmt,
+                utils::VectorRef<const Attribute*> attributes);
     /// Move constructor
     IfStatement(IfStatement&&);
     ~IfStatement() override;
@@ -56,6 +58,9 @@
 
     /// The optional else statement, or nullptr
     const Statement* const else_statement;
+
+    /// The attribute list
+    const utils::Vector<const Attribute*, 1> attributes;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/if_statement_test.cc b/src/tint/ast/if_statement_test.cc
index 9115cb7..b5b85fe 100644
--- a/src/tint/ast/if_statement_test.cc
+++ b/src/tint/ast/if_statement_test.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/ast/if_statement.h"
 
+#include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "src/tint/ast/discard_statement.h"
 #include "src/tint/ast/test_helper.h"
@@ -31,6 +32,15 @@
     EXPECT_EQ(src.range.begin.column, 2u);
 }
 
+TEST_F(IfStatementTest, Creation_WithAttributes) {
+    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "foo");
+    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "bar");
+    auto* cond = Expr("cond");
+    auto* stmt = If(cond, Block(), ElseStmt(), utils::Vector{attr1, attr2});
+
+    EXPECT_THAT(stmt->attributes, testing::ElementsAre(attr1, attr2));
+}
+
 TEST_F(IfStatementTest, IsIf) {
     auto* stmt = If(Expr(true), Block());
     EXPECT_TRUE(stmt->Is<IfStatement>());
diff --git a/src/tint/ast/module.cc b/src/tint/ast/module.cc
index 32dafe8..fa652de 100644
--- a/src/tint/ast/module.cc
+++ b/src/tint/ast/module.cc
@@ -18,6 +18,7 @@
 
 #include "src/tint/ast/type_decl.h"
 #include "src/tint/program_builder.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ast::Module);
 
diff --git a/src/tint/ast/switch_statement.cc b/src/tint/ast/switch_statement.cc
index 1cdf8a4..0445e48 100644
--- a/src/tint/ast/switch_statement.cc
+++ b/src/tint/ast/switch_statement.cc
@@ -26,14 +26,19 @@
                                  NodeID nid,
                                  const Source& src,
                                  const Expression* cond,
-                                 utils::VectorRef<const CaseStatement*> b)
-    : Base(pid, nid, src), condition(cond), body(std::move(b)) {
+                                 utils::VectorRef<const CaseStatement*> b,
+                                 utils::VectorRef<const Attribute*> attrs)
+    : Base(pid, nid, src), condition(cond), body(std::move(b)), attributes(std::move(attrs)) {
     TINT_ASSERT(AST, condition);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, condition, program_id);
     for (auto* stmt : body) {
         TINT_ASSERT(AST, stmt);
         TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, stmt, program_id);
     }
+    for (auto* attr : attributes) {
+        TINT_ASSERT(AST, attr);
+        TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, attr, program_id);
+    }
 }
 
 SwitchStatement::SwitchStatement(SwitchStatement&&) = default;
@@ -45,7 +50,8 @@
     auto src = ctx->Clone(source);
     auto* cond = ctx->Clone(condition);
     auto b = ctx->Clone(body);
-    return ctx->dst->create<SwitchStatement>(src, cond, std::move(b));
+    auto attrs = ctx->Clone(attributes);
+    return ctx->dst->create<SwitchStatement>(src, cond, std::move(b), std::move(attrs));
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/switch_statement.h b/src/tint/ast/switch_statement.h
index eb083f0..e918535 100644
--- a/src/tint/ast/switch_statement.h
+++ b/src/tint/ast/switch_statement.h
@@ -29,11 +29,13 @@
     /// @param src the source of this node
     /// @param condition the switch condition
     /// @param body the switch body
+    /// @param attributes the switch statement attributes
     SwitchStatement(ProgramID pid,
                     NodeID nid,
                     const Source& src,
                     const Expression* condition,
-                    utils::VectorRef<const CaseStatement*> body);
+                    utils::VectorRef<const CaseStatement*> body,
+                    utils::VectorRef<const Attribute*> attributes);
     /// Move constructor
     SwitchStatement(SwitchStatement&&);
     ~SwitchStatement() override;
@@ -50,6 +52,9 @@
     /// The Switch body
     const utils::Vector<const CaseStatement*, 4> body;
     SwitchStatement(const SwitchStatement&) = delete;
+
+    /// The attribute list
+    const utils::Vector<const Attribute*, 1> attributes;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/switch_statement_test.cc b/src/tint/ast/switch_statement_test.cc
index e6101c8..aab2604 100644
--- a/src/tint/ast/switch_statement_test.cc
+++ b/src/tint/ast/switch_statement_test.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/ast/switch_statement.h"
 
+#include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "src/tint/ast/test_helper.h"
 
@@ -29,7 +30,7 @@
     auto* ident = Expr("ident");
     utils::Vector body{case_stmt};
 
-    auto* stmt = create<SwitchStatement>(ident, body);
+    auto* stmt = create<SwitchStatement>(ident, body, utils::Empty);
     EXPECT_EQ(stmt->condition, ident);
     ASSERT_EQ(stmt->body.Length(), 1u);
     EXPECT_EQ(stmt->body[0], case_stmt);
@@ -37,18 +38,28 @@
 
 TEST_F(SwitchStatementTest, Creation_WithSource) {
     auto* ident = Expr("ident");
-    auto* stmt = create<SwitchStatement>(Source{Source::Location{20, 2}}, ident, utils::Empty);
+    auto* stmt =
+        create<SwitchStatement>(Source{Source::Location{20, 2}}, ident, utils::Empty, utils::Empty);
     auto src = stmt->source;
     EXPECT_EQ(src.range.begin.line, 20u);
     EXPECT_EQ(src.range.begin.column, 2u);
 }
 
+TEST_F(SwitchStatementTest, Creation_WithAttributes) {
+    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "foo");
+    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "bar");
+    auto* ident = Expr("ident");
+    auto* stmt = create<SwitchStatement>(ident, utils::Empty, utils::Vector{attr1, attr2});
+
+    EXPECT_THAT(stmt->attributes, testing::ElementsAre(attr1, attr2));
+}
+
 TEST_F(SwitchStatementTest, IsSwitch) {
     utils::Vector lit{CaseSelector(2_i)};
     auto* ident = Expr("ident");
     utils::Vector body{create<CaseStatement>(lit, Block())};
 
-    auto* stmt = create<SwitchStatement>(ident, body);
+    auto* stmt = create<SwitchStatement>(ident, body, utils::Empty);
     EXPECT_TRUE(stmt->Is<SwitchStatement>());
 }
 
@@ -60,7 +71,7 @@
             CaseStatementList cases;
             cases.Push(
                 b.create<CaseStatement>(utils::Vector{b.CaseSelector(b.Expr(1_i))}, b.Block()));
-            b.create<SwitchStatement>(nullptr, cases);
+            b.create<SwitchStatement>(nullptr, cases, utils::Empty);
         },
         "internal compiler error");
 }
@@ -70,7 +81,7 @@
     EXPECT_FATAL_FAILURE(
         {
             ProgramBuilder b;
-            b.create<SwitchStatement>(b.Expr(true), CaseStatementList{nullptr});
+            b.create<SwitchStatement>(b.Expr(true), CaseStatementList{nullptr}, utils::Empty);
         },
         "internal compiler error");
 }
@@ -80,13 +91,15 @@
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.create<SwitchStatement>(b2.Expr(true), utils::Vector{
-                                                          b1.create<CaseStatement>(
-                                                              utils::Vector{
-                                                                  b1.CaseSelector(b1.Expr(1_i)),
-                                                              },
-                                                              b1.Block()),
-                                                      });
+            b1.create<SwitchStatement>(b2.Expr(true),
+                                       utils::Vector{
+                                           b1.create<CaseStatement>(
+                                               utils::Vector{
+                                                   b1.CaseSelector(b1.Expr(1_i)),
+                                               },
+                                               b1.Block()),
+                                       },
+                                       utils::Empty);
         },
         "internal compiler error");
 }
@@ -96,13 +109,15 @@
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.create<SwitchStatement>(b1.Expr(true), utils::Vector{
-                                                          b2.create<CaseStatement>(
-                                                              utils::Vector{
-                                                                  b2.CaseSelector(b2.Expr(1_i)),
-                                                              },
-                                                              b2.Block()),
-                                                      });
+            b1.create<SwitchStatement>(b1.Expr(true),
+                                       utils::Vector{
+                                           b2.create<CaseStatement>(
+                                               utils::Vector{
+                                                   b2.CaseSelector(b2.Expr(1_i)),
+                                               },
+                                               b2.Block()),
+                                       },
+                                       utils::Empty);
         },
         "internal compiler error");
 }
diff --git a/src/tint/ast/traverse_expressions.h b/src/tint/ast/traverse_expressions.h
index fb8aad1..84a10c3 100644
--- a/src/tint/ast/traverse_expressions.h
+++ b/src/tint/ast/traverse_expressions.h
@@ -25,6 +25,7 @@
 #include "src/tint/ast/member_accessor_expression.h"
 #include "src/tint/ast/phony_expression.h"
 #include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/compiler_macros.h"
 #include "src/tint/utils/reverse.h"
 #include "src/tint/utils/vector.h"
diff --git a/src/tint/ast/while_statement.cc b/src/tint/ast/while_statement.cc
index 160af4b..47cf2bb 100644
--- a/src/tint/ast/while_statement.cc
+++ b/src/tint/ast/while_statement.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/ast/while_statement.h"
 
+#include <utility>
+
 #include "src/tint/program_builder.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ast::WhileStatement);
@@ -24,13 +26,18 @@
                                NodeID nid,
                                const Source& src,
                                const Expression* cond,
-                               const BlockStatement* b)
-    : Base(pid, nid, src), condition(cond), body(b) {
+                               const BlockStatement* b,
+                               utils::VectorRef<const ast::Attribute*> attrs)
+    : Base(pid, nid, src), condition(cond), body(b), attributes(std::move(attrs)) {
     TINT_ASSERT(AST, cond);
     TINT_ASSERT(AST, body);
 
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, condition, program_id);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, body, program_id);
+    for (auto* attr : attributes) {
+        TINT_ASSERT(AST, attr);
+        TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, attr, program_id);
+    }
 }
 
 WhileStatement::WhileStatement(WhileStatement&&) = default;
@@ -43,7 +50,8 @@
 
     auto* cond = ctx->Clone(condition);
     auto* b = ctx->Clone(body);
-    return ctx->dst->create<WhileStatement>(src, cond, b);
+    auto attrs = ctx->Clone(attributes);
+    return ctx->dst->create<WhileStatement>(src, cond, b, std::move(attrs));
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/while_statement.h b/src/tint/ast/while_statement.h
index 4e8dd7e..b2b91dc 100644
--- a/src/tint/ast/while_statement.h
+++ b/src/tint/ast/while_statement.h
@@ -30,11 +30,13 @@
     /// @param source the for loop statement source
     /// @param condition the optional loop condition expression
     /// @param body the loop body
+    /// @param attributes the while statement attributes
     WhileStatement(ProgramID pid,
                    NodeID nid,
                    const Source& source,
                    const Expression* condition,
-                   const BlockStatement* body);
+                   const BlockStatement* body,
+                   utils::VectorRef<const ast::Attribute*> attributes);
     /// Move constructor
     WhileStatement(WhileStatement&&);
     ~WhileStatement() override;
@@ -50,6 +52,9 @@
 
     /// The loop body block
     const BlockStatement* const body;
+
+    /// The attribute list
+    const utils::Vector<const Attribute*, 1> attributes;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/while_statement_test.cc b/src/tint/ast/while_statement_test.cc
index 73c9e56..ef287fc 100644
--- a/src/tint/ast/while_statement_test.cc
+++ b/src/tint/ast/while_statement_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "src/tint/ast/binary_expression.h"
 #include "src/tint/ast/test_helper.h"
@@ -41,6 +42,16 @@
     EXPECT_EQ(src.range.begin.column, 2u);
 }
 
+TEST_F(WhileStatementTest, Creation_WithAttributes) {
+    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "foo");
+    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "bar");
+    auto* cond = create<BinaryExpression>(BinaryOp::kLessThan, Expr("i"), Expr(5_u));
+    auto* body = Block(Return());
+    auto* l = While(cond, body, utils::Vector{attr1, attr2});
+
+    EXPECT_THAT(l->attributes, testing::ElementsAre(attr1, attr2));
+}
+
 TEST_F(WhileStatementTest, Assert_Null_Cond) {
     EXPECT_FATAL_FAILURE(
         {
diff --git a/src/tint/builtin/function.cc b/src/tint/builtin/function.cc
new file mode 100644
index 0000000..88e86b6
--- /dev/null
+++ b/src/tint/builtin/function.cc
@@ -0,0 +1,614 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/builtin/function.cc.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
+#include "src/tint/builtin/function.h"
+
+namespace tint::builtin {
+
+Function ParseFunction(const std::string& name) {
+    if (name == "abs") {
+        return Function::kAbs;
+    }
+    if (name == "acos") {
+        return Function::kAcos;
+    }
+    if (name == "acosh") {
+        return Function::kAcosh;
+    }
+    if (name == "all") {
+        return Function::kAll;
+    }
+    if (name == "any") {
+        return Function::kAny;
+    }
+    if (name == "arrayLength") {
+        return Function::kArrayLength;
+    }
+    if (name == "asin") {
+        return Function::kAsin;
+    }
+    if (name == "asinh") {
+        return Function::kAsinh;
+    }
+    if (name == "atan") {
+        return Function::kAtan;
+    }
+    if (name == "atan2") {
+        return Function::kAtan2;
+    }
+    if (name == "atanh") {
+        return Function::kAtanh;
+    }
+    if (name == "ceil") {
+        return Function::kCeil;
+    }
+    if (name == "clamp") {
+        return Function::kClamp;
+    }
+    if (name == "cos") {
+        return Function::kCos;
+    }
+    if (name == "cosh") {
+        return Function::kCosh;
+    }
+    if (name == "countLeadingZeros") {
+        return Function::kCountLeadingZeros;
+    }
+    if (name == "countOneBits") {
+        return Function::kCountOneBits;
+    }
+    if (name == "countTrailingZeros") {
+        return Function::kCountTrailingZeros;
+    }
+    if (name == "cross") {
+        return Function::kCross;
+    }
+    if (name == "degrees") {
+        return Function::kDegrees;
+    }
+    if (name == "determinant") {
+        return Function::kDeterminant;
+    }
+    if (name == "distance") {
+        return Function::kDistance;
+    }
+    if (name == "dot") {
+        return Function::kDot;
+    }
+    if (name == "dot4I8Packed") {
+        return Function::kDot4I8Packed;
+    }
+    if (name == "dot4U8Packed") {
+        return Function::kDot4U8Packed;
+    }
+    if (name == "dpdx") {
+        return Function::kDpdx;
+    }
+    if (name == "dpdxCoarse") {
+        return Function::kDpdxCoarse;
+    }
+    if (name == "dpdxFine") {
+        return Function::kDpdxFine;
+    }
+    if (name == "dpdy") {
+        return Function::kDpdy;
+    }
+    if (name == "dpdyCoarse") {
+        return Function::kDpdyCoarse;
+    }
+    if (name == "dpdyFine") {
+        return Function::kDpdyFine;
+    }
+    if (name == "exp") {
+        return Function::kExp;
+    }
+    if (name == "exp2") {
+        return Function::kExp2;
+    }
+    if (name == "extractBits") {
+        return Function::kExtractBits;
+    }
+    if (name == "faceForward") {
+        return Function::kFaceForward;
+    }
+    if (name == "firstLeadingBit") {
+        return Function::kFirstLeadingBit;
+    }
+    if (name == "firstTrailingBit") {
+        return Function::kFirstTrailingBit;
+    }
+    if (name == "floor") {
+        return Function::kFloor;
+    }
+    if (name == "fma") {
+        return Function::kFma;
+    }
+    if (name == "fract") {
+        return Function::kFract;
+    }
+    if (name == "frexp") {
+        return Function::kFrexp;
+    }
+    if (name == "fwidth") {
+        return Function::kFwidth;
+    }
+    if (name == "fwidthCoarse") {
+        return Function::kFwidthCoarse;
+    }
+    if (name == "fwidthFine") {
+        return Function::kFwidthFine;
+    }
+    if (name == "insertBits") {
+        return Function::kInsertBits;
+    }
+    if (name == "inverseSqrt") {
+        return Function::kInverseSqrt;
+    }
+    if (name == "ldexp") {
+        return Function::kLdexp;
+    }
+    if (name == "length") {
+        return Function::kLength;
+    }
+    if (name == "log") {
+        return Function::kLog;
+    }
+    if (name == "log2") {
+        return Function::kLog2;
+    }
+    if (name == "max") {
+        return Function::kMax;
+    }
+    if (name == "min") {
+        return Function::kMin;
+    }
+    if (name == "mix") {
+        return Function::kMix;
+    }
+    if (name == "modf") {
+        return Function::kModf;
+    }
+    if (name == "normalize") {
+        return Function::kNormalize;
+    }
+    if (name == "pack2x16float") {
+        return Function::kPack2X16Float;
+    }
+    if (name == "pack2x16snorm") {
+        return Function::kPack2X16Snorm;
+    }
+    if (name == "pack2x16unorm") {
+        return Function::kPack2X16Unorm;
+    }
+    if (name == "pack4x8snorm") {
+        return Function::kPack4X8Snorm;
+    }
+    if (name == "pack4x8unorm") {
+        return Function::kPack4X8Unorm;
+    }
+    if (name == "pow") {
+        return Function::kPow;
+    }
+    if (name == "quantizeToF16") {
+        return Function::kQuantizeToF16;
+    }
+    if (name == "radians") {
+        return Function::kRadians;
+    }
+    if (name == "reflect") {
+        return Function::kReflect;
+    }
+    if (name == "refract") {
+        return Function::kRefract;
+    }
+    if (name == "reverseBits") {
+        return Function::kReverseBits;
+    }
+    if (name == "round") {
+        return Function::kRound;
+    }
+    if (name == "saturate") {
+        return Function::kSaturate;
+    }
+    if (name == "select") {
+        return Function::kSelect;
+    }
+    if (name == "sign") {
+        return Function::kSign;
+    }
+    if (name == "sin") {
+        return Function::kSin;
+    }
+    if (name == "sinh") {
+        return Function::kSinh;
+    }
+    if (name == "smoothstep") {
+        return Function::kSmoothstep;
+    }
+    if (name == "sqrt") {
+        return Function::kSqrt;
+    }
+    if (name == "step") {
+        return Function::kStep;
+    }
+    if (name == "storageBarrier") {
+        return Function::kStorageBarrier;
+    }
+    if (name == "tan") {
+        return Function::kTan;
+    }
+    if (name == "tanh") {
+        return Function::kTanh;
+    }
+    if (name == "transpose") {
+        return Function::kTranspose;
+    }
+    if (name == "trunc") {
+        return Function::kTrunc;
+    }
+    if (name == "unpack2x16float") {
+        return Function::kUnpack2X16Float;
+    }
+    if (name == "unpack2x16snorm") {
+        return Function::kUnpack2X16Snorm;
+    }
+    if (name == "unpack2x16unorm") {
+        return Function::kUnpack2X16Unorm;
+    }
+    if (name == "unpack4x8snorm") {
+        return Function::kUnpack4X8Snorm;
+    }
+    if (name == "unpack4x8unorm") {
+        return Function::kUnpack4X8Unorm;
+    }
+    if (name == "workgroupBarrier") {
+        return Function::kWorkgroupBarrier;
+    }
+    if (name == "workgroupUniformLoad") {
+        return Function::kWorkgroupUniformLoad;
+    }
+    if (name == "textureDimensions") {
+        return Function::kTextureDimensions;
+    }
+    if (name == "textureGather") {
+        return Function::kTextureGather;
+    }
+    if (name == "textureGatherCompare") {
+        return Function::kTextureGatherCompare;
+    }
+    if (name == "textureNumLayers") {
+        return Function::kTextureNumLayers;
+    }
+    if (name == "textureNumLevels") {
+        return Function::kTextureNumLevels;
+    }
+    if (name == "textureNumSamples") {
+        return Function::kTextureNumSamples;
+    }
+    if (name == "textureSample") {
+        return Function::kTextureSample;
+    }
+    if (name == "textureSampleBias") {
+        return Function::kTextureSampleBias;
+    }
+    if (name == "textureSampleCompare") {
+        return Function::kTextureSampleCompare;
+    }
+    if (name == "textureSampleCompareLevel") {
+        return Function::kTextureSampleCompareLevel;
+    }
+    if (name == "textureSampleGrad") {
+        return Function::kTextureSampleGrad;
+    }
+    if (name == "textureSampleLevel") {
+        return Function::kTextureSampleLevel;
+    }
+    if (name == "textureSampleBaseClampToEdge") {
+        return Function::kTextureSampleBaseClampToEdge;
+    }
+    if (name == "textureStore") {
+        return Function::kTextureStore;
+    }
+    if (name == "textureLoad") {
+        return Function::kTextureLoad;
+    }
+    if (name == "atomicLoad") {
+        return Function::kAtomicLoad;
+    }
+    if (name == "atomicStore") {
+        return Function::kAtomicStore;
+    }
+    if (name == "atomicAdd") {
+        return Function::kAtomicAdd;
+    }
+    if (name == "atomicSub") {
+        return Function::kAtomicSub;
+    }
+    if (name == "atomicMax") {
+        return Function::kAtomicMax;
+    }
+    if (name == "atomicMin") {
+        return Function::kAtomicMin;
+    }
+    if (name == "atomicAnd") {
+        return Function::kAtomicAnd;
+    }
+    if (name == "atomicOr") {
+        return Function::kAtomicOr;
+    }
+    if (name == "atomicXor") {
+        return Function::kAtomicXor;
+    }
+    if (name == "atomicExchange") {
+        return Function::kAtomicExchange;
+    }
+    if (name == "atomicCompareExchangeWeak") {
+        return Function::kAtomicCompareExchangeWeak;
+    }
+    if (name == "_tint_materialize") {
+        return Function::kTintMaterialize;
+    }
+    return Function::kNone;
+}
+
+const char* str(Function i) {
+    switch (i) {
+        case Function::kNone:
+            return "<none>";
+        case Function::kAbs:
+            return "abs";
+        case Function::kAcos:
+            return "acos";
+        case Function::kAcosh:
+            return "acosh";
+        case Function::kAll:
+            return "all";
+        case Function::kAny:
+            return "any";
+        case Function::kArrayLength:
+            return "arrayLength";
+        case Function::kAsin:
+            return "asin";
+        case Function::kAsinh:
+            return "asinh";
+        case Function::kAtan:
+            return "atan";
+        case Function::kAtan2:
+            return "atan2";
+        case Function::kAtanh:
+            return "atanh";
+        case Function::kCeil:
+            return "ceil";
+        case Function::kClamp:
+            return "clamp";
+        case Function::kCos:
+            return "cos";
+        case Function::kCosh:
+            return "cosh";
+        case Function::kCountLeadingZeros:
+            return "countLeadingZeros";
+        case Function::kCountOneBits:
+            return "countOneBits";
+        case Function::kCountTrailingZeros:
+            return "countTrailingZeros";
+        case Function::kCross:
+            return "cross";
+        case Function::kDegrees:
+            return "degrees";
+        case Function::kDeterminant:
+            return "determinant";
+        case Function::kDistance:
+            return "distance";
+        case Function::kDot:
+            return "dot";
+        case Function::kDot4I8Packed:
+            return "dot4I8Packed";
+        case Function::kDot4U8Packed:
+            return "dot4U8Packed";
+        case Function::kDpdx:
+            return "dpdx";
+        case Function::kDpdxCoarse:
+            return "dpdxCoarse";
+        case Function::kDpdxFine:
+            return "dpdxFine";
+        case Function::kDpdy:
+            return "dpdy";
+        case Function::kDpdyCoarse:
+            return "dpdyCoarse";
+        case Function::kDpdyFine:
+            return "dpdyFine";
+        case Function::kExp:
+            return "exp";
+        case Function::kExp2:
+            return "exp2";
+        case Function::kExtractBits:
+            return "extractBits";
+        case Function::kFaceForward:
+            return "faceForward";
+        case Function::kFirstLeadingBit:
+            return "firstLeadingBit";
+        case Function::kFirstTrailingBit:
+            return "firstTrailingBit";
+        case Function::kFloor:
+            return "floor";
+        case Function::kFma:
+            return "fma";
+        case Function::kFract:
+            return "fract";
+        case Function::kFrexp:
+            return "frexp";
+        case Function::kFwidth:
+            return "fwidth";
+        case Function::kFwidthCoarse:
+            return "fwidthCoarse";
+        case Function::kFwidthFine:
+            return "fwidthFine";
+        case Function::kInsertBits:
+            return "insertBits";
+        case Function::kInverseSqrt:
+            return "inverseSqrt";
+        case Function::kLdexp:
+            return "ldexp";
+        case Function::kLength:
+            return "length";
+        case Function::kLog:
+            return "log";
+        case Function::kLog2:
+            return "log2";
+        case Function::kMax:
+            return "max";
+        case Function::kMin:
+            return "min";
+        case Function::kMix:
+            return "mix";
+        case Function::kModf:
+            return "modf";
+        case Function::kNormalize:
+            return "normalize";
+        case Function::kPack2X16Float:
+            return "pack2x16float";
+        case Function::kPack2X16Snorm:
+            return "pack2x16snorm";
+        case Function::kPack2X16Unorm:
+            return "pack2x16unorm";
+        case Function::kPack4X8Snorm:
+            return "pack4x8snorm";
+        case Function::kPack4X8Unorm:
+            return "pack4x8unorm";
+        case Function::kPow:
+            return "pow";
+        case Function::kQuantizeToF16:
+            return "quantizeToF16";
+        case Function::kRadians:
+            return "radians";
+        case Function::kReflect:
+            return "reflect";
+        case Function::kRefract:
+            return "refract";
+        case Function::kReverseBits:
+            return "reverseBits";
+        case Function::kRound:
+            return "round";
+        case Function::kSaturate:
+            return "saturate";
+        case Function::kSelect:
+            return "select";
+        case Function::kSign:
+            return "sign";
+        case Function::kSin:
+            return "sin";
+        case Function::kSinh:
+            return "sinh";
+        case Function::kSmoothstep:
+            return "smoothstep";
+        case Function::kSqrt:
+            return "sqrt";
+        case Function::kStep:
+            return "step";
+        case Function::kStorageBarrier:
+            return "storageBarrier";
+        case Function::kTan:
+            return "tan";
+        case Function::kTanh:
+            return "tanh";
+        case Function::kTranspose:
+            return "transpose";
+        case Function::kTrunc:
+            return "trunc";
+        case Function::kUnpack2X16Float:
+            return "unpack2x16float";
+        case Function::kUnpack2X16Snorm:
+            return "unpack2x16snorm";
+        case Function::kUnpack2X16Unorm:
+            return "unpack2x16unorm";
+        case Function::kUnpack4X8Snorm:
+            return "unpack4x8snorm";
+        case Function::kUnpack4X8Unorm:
+            return "unpack4x8unorm";
+        case Function::kWorkgroupBarrier:
+            return "workgroupBarrier";
+        case Function::kWorkgroupUniformLoad:
+            return "workgroupUniformLoad";
+        case Function::kTextureDimensions:
+            return "textureDimensions";
+        case Function::kTextureGather:
+            return "textureGather";
+        case Function::kTextureGatherCompare:
+            return "textureGatherCompare";
+        case Function::kTextureNumLayers:
+            return "textureNumLayers";
+        case Function::kTextureNumLevels:
+            return "textureNumLevels";
+        case Function::kTextureNumSamples:
+            return "textureNumSamples";
+        case Function::kTextureSample:
+            return "textureSample";
+        case Function::kTextureSampleBias:
+            return "textureSampleBias";
+        case Function::kTextureSampleCompare:
+            return "textureSampleCompare";
+        case Function::kTextureSampleCompareLevel:
+            return "textureSampleCompareLevel";
+        case Function::kTextureSampleGrad:
+            return "textureSampleGrad";
+        case Function::kTextureSampleLevel:
+            return "textureSampleLevel";
+        case Function::kTextureSampleBaseClampToEdge:
+            return "textureSampleBaseClampToEdge";
+        case Function::kTextureStore:
+            return "textureStore";
+        case Function::kTextureLoad:
+            return "textureLoad";
+        case Function::kAtomicLoad:
+            return "atomicLoad";
+        case Function::kAtomicStore:
+            return "atomicStore";
+        case Function::kAtomicAdd:
+            return "atomicAdd";
+        case Function::kAtomicSub:
+            return "atomicSub";
+        case Function::kAtomicMax:
+            return "atomicMax";
+        case Function::kAtomicMin:
+            return "atomicMin";
+        case Function::kAtomicAnd:
+            return "atomicAnd";
+        case Function::kAtomicOr:
+            return "atomicOr";
+        case Function::kAtomicXor:
+            return "atomicXor";
+        case Function::kAtomicExchange:
+            return "atomicExchange";
+        case Function::kAtomicCompareExchangeWeak:
+            return "atomicCompareExchangeWeak";
+        case Function::kTintMaterialize:
+            return "_tint_materialize";
+    }
+    return "<unknown>";
+}
+
+utils::StringStream& operator<<(utils::StringStream& out, Function i) {
+    out << str(i);
+    return out;
+}
+
+}  // namespace tint::builtin
diff --git a/src/tint/builtin/function.cc.tmpl b/src/tint/builtin/function.cc.tmpl
new file mode 100644
index 0000000..e2729dc
--- /dev/null
+++ b/src/tint/builtin/function.cc.tmpl
@@ -0,0 +1,44 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate function.cc
+
+To update the generated file, run:
+    ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+#include "src/tint/builtin/function.h"
+
+namespace tint::builtin {
+
+Function ParseFunction(const std::string& name) {
+{{- range Sem.Builtins  }}
+    if (name == "{{.Name}}") {
+        return Function::k{{PascalCase .Name}};
+    }
+{{- end  }}
+    return Function::kNone;
+}
+
+const char* str(Function i) {
+    switch (i) {
+        case Function::kNone:
+            return "<none>";
+{{- range Sem.Builtins  }}
+        case Function::k{{PascalCase .Name}}:
+            return "{{.Name}}";
+{{- end  }}
+    }
+    return "<unknown>";
+}
+
+utils::StringStream& operator<<(utils::StringStream& out, Function i) {
+    out << str(i);
+    return out;
+}
+
+}  // namespace tint::builtin
diff --git a/src/tint/builtin/function.h b/src/tint/builtin/function.h
new file mode 100644
index 0000000..3ccb341
--- /dev/null
+++ b/src/tint/builtin/function.h
@@ -0,0 +1,405 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/builtin/function.h.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef SRC_TINT_BUILTIN_FUNCTION_H_
+#define SRC_TINT_BUILTIN_FUNCTION_H_
+
+#include <string>
+
+#include "src/tint/utils/string_stream.h"
+
+// \cond DO_NOT_DOCUMENT
+namespace tint::builtin {
+
+/// Enumerator of all builtin functions
+enum class Function {
+    kNone = -1,
+    kAbs,
+    kAcos,
+    kAcosh,
+    kAll,
+    kAny,
+    kArrayLength,
+    kAsin,
+    kAsinh,
+    kAtan,
+    kAtan2,
+    kAtanh,
+    kCeil,
+    kClamp,
+    kCos,
+    kCosh,
+    kCountLeadingZeros,
+    kCountOneBits,
+    kCountTrailingZeros,
+    kCross,
+    kDegrees,
+    kDeterminant,
+    kDistance,
+    kDot,
+    kDot4I8Packed,
+    kDot4U8Packed,
+    kDpdx,
+    kDpdxCoarse,
+    kDpdxFine,
+    kDpdy,
+    kDpdyCoarse,
+    kDpdyFine,
+    kExp,
+    kExp2,
+    kExtractBits,
+    kFaceForward,
+    kFirstLeadingBit,
+    kFirstTrailingBit,
+    kFloor,
+    kFma,
+    kFract,
+    kFrexp,
+    kFwidth,
+    kFwidthCoarse,
+    kFwidthFine,
+    kInsertBits,
+    kInverseSqrt,
+    kLdexp,
+    kLength,
+    kLog,
+    kLog2,
+    kMax,
+    kMin,
+    kMix,
+    kModf,
+    kNormalize,
+    kPack2X16Float,
+    kPack2X16Snorm,
+    kPack2X16Unorm,
+    kPack4X8Snorm,
+    kPack4X8Unorm,
+    kPow,
+    kQuantizeToF16,
+    kRadians,
+    kReflect,
+    kRefract,
+    kReverseBits,
+    kRound,
+    kSaturate,
+    kSelect,
+    kSign,
+    kSin,
+    kSinh,
+    kSmoothstep,
+    kSqrt,
+    kStep,
+    kStorageBarrier,
+    kTan,
+    kTanh,
+    kTranspose,
+    kTrunc,
+    kUnpack2X16Float,
+    kUnpack2X16Snorm,
+    kUnpack2X16Unorm,
+    kUnpack4X8Snorm,
+    kUnpack4X8Unorm,
+    kWorkgroupBarrier,
+    kWorkgroupUniformLoad,
+    kTextureDimensions,
+    kTextureGather,
+    kTextureGatherCompare,
+    kTextureNumLayers,
+    kTextureNumLevels,
+    kTextureNumSamples,
+    kTextureSample,
+    kTextureSampleBias,
+    kTextureSampleCompare,
+    kTextureSampleCompareLevel,
+    kTextureSampleGrad,
+    kTextureSampleLevel,
+    kTextureSampleBaseClampToEdge,
+    kTextureStore,
+    kTextureLoad,
+    kAtomicLoad,
+    kAtomicStore,
+    kAtomicAdd,
+    kAtomicSub,
+    kAtomicMax,
+    kAtomicMin,
+    kAtomicAnd,
+    kAtomicOr,
+    kAtomicXor,
+    kAtomicExchange,
+    kAtomicCompareExchangeWeak,
+    kTintMaterialize,
+};
+
+/// Matches the Function by name
+/// @param name the builtin name to parse
+/// @returns the parsed Function, or Function::kNone if `name` did not
+/// match any builtin function.
+Function ParseFunction(const std::string& name);
+
+/// @returns the name of the builtin function type. The spelling, including
+/// case, matches the name in the WGSL spec.
+const char* str(Function i);
+
+/// Emits the name of the builtin function type. The spelling, including case,
+/// matches the name in the WGSL spec.
+utils::StringStream& operator<<(utils::StringStream& out, Function i);
+
+/// All builtin functions
+constexpr Function kFunctions[] = {
+    Function::kAbs,
+    Function::kAcos,
+    Function::kAcosh,
+    Function::kAll,
+    Function::kAny,
+    Function::kArrayLength,
+    Function::kAsin,
+    Function::kAsinh,
+    Function::kAtan,
+    Function::kAtan2,
+    Function::kAtanh,
+    Function::kCeil,
+    Function::kClamp,
+    Function::kCos,
+    Function::kCosh,
+    Function::kCountLeadingZeros,
+    Function::kCountOneBits,
+    Function::kCountTrailingZeros,
+    Function::kCross,
+    Function::kDegrees,
+    Function::kDeterminant,
+    Function::kDistance,
+    Function::kDot,
+    Function::kDot4I8Packed,
+    Function::kDot4U8Packed,
+    Function::kDpdx,
+    Function::kDpdxCoarse,
+    Function::kDpdxFine,
+    Function::kDpdy,
+    Function::kDpdyCoarse,
+    Function::kDpdyFine,
+    Function::kExp,
+    Function::kExp2,
+    Function::kExtractBits,
+    Function::kFaceForward,
+    Function::kFirstLeadingBit,
+    Function::kFirstTrailingBit,
+    Function::kFloor,
+    Function::kFma,
+    Function::kFract,
+    Function::kFrexp,
+    Function::kFwidth,
+    Function::kFwidthCoarse,
+    Function::kFwidthFine,
+    Function::kInsertBits,
+    Function::kInverseSqrt,
+    Function::kLdexp,
+    Function::kLength,
+    Function::kLog,
+    Function::kLog2,
+    Function::kMax,
+    Function::kMin,
+    Function::kMix,
+    Function::kModf,
+    Function::kNormalize,
+    Function::kPack2X16Float,
+    Function::kPack2X16Snorm,
+    Function::kPack2X16Unorm,
+    Function::kPack4X8Snorm,
+    Function::kPack4X8Unorm,
+    Function::kPow,
+    Function::kQuantizeToF16,
+    Function::kRadians,
+    Function::kReflect,
+    Function::kRefract,
+    Function::kReverseBits,
+    Function::kRound,
+    Function::kSaturate,
+    Function::kSelect,
+    Function::kSign,
+    Function::kSin,
+    Function::kSinh,
+    Function::kSmoothstep,
+    Function::kSqrt,
+    Function::kStep,
+    Function::kStorageBarrier,
+    Function::kTan,
+    Function::kTanh,
+    Function::kTranspose,
+    Function::kTrunc,
+    Function::kUnpack2X16Float,
+    Function::kUnpack2X16Snorm,
+    Function::kUnpack2X16Unorm,
+    Function::kUnpack4X8Snorm,
+    Function::kUnpack4X8Unorm,
+    Function::kWorkgroupBarrier,
+    Function::kWorkgroupUniformLoad,
+    Function::kTextureDimensions,
+    Function::kTextureGather,
+    Function::kTextureGatherCompare,
+    Function::kTextureNumLayers,
+    Function::kTextureNumLevels,
+    Function::kTextureNumSamples,
+    Function::kTextureSample,
+    Function::kTextureSampleBias,
+    Function::kTextureSampleCompare,
+    Function::kTextureSampleCompareLevel,
+    Function::kTextureSampleGrad,
+    Function::kTextureSampleLevel,
+    Function::kTextureSampleBaseClampToEdge,
+    Function::kTextureStore,
+    Function::kTextureLoad,
+    Function::kAtomicLoad,
+    Function::kAtomicStore,
+    Function::kAtomicAdd,
+    Function::kAtomicSub,
+    Function::kAtomicMax,
+    Function::kAtomicMin,
+    Function::kAtomicAnd,
+    Function::kAtomicOr,
+    Function::kAtomicXor,
+    Function::kAtomicExchange,
+    Function::kAtomicCompareExchangeWeak,
+    Function::kTintMaterialize,
+};
+
+/// All builtin function names
+constexpr const char* kFunctionStrings[] = {
+    "abs",
+    "acos",
+    "acosh",
+    "all",
+    "any",
+    "arrayLength",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "ceil",
+    "clamp",
+    "cos",
+    "cosh",
+    "countLeadingZeros",
+    "countOneBits",
+    "countTrailingZeros",
+    "cross",
+    "degrees",
+    "determinant",
+    "distance",
+    "dot",
+    "dot4I8Packed",
+    "dot4U8Packed",
+    "dpdx",
+    "dpdxCoarse",
+    "dpdxFine",
+    "dpdy",
+    "dpdyCoarse",
+    "dpdyFine",
+    "exp",
+    "exp2",
+    "extractBits",
+    "faceForward",
+    "firstLeadingBit",
+    "firstTrailingBit",
+    "floor",
+    "fma",
+    "fract",
+    "frexp",
+    "fwidth",
+    "fwidthCoarse",
+    "fwidthFine",
+    "insertBits",
+    "inverseSqrt",
+    "ldexp",
+    "length",
+    "log",
+    "log2",
+    "max",
+    "min",
+    "mix",
+    "modf",
+    "normalize",
+    "pack2x16float",
+    "pack2x16snorm",
+    "pack2x16unorm",
+    "pack4x8snorm",
+    "pack4x8unorm",
+    "pow",
+    "quantizeToF16",
+    "radians",
+    "reflect",
+    "refract",
+    "reverseBits",
+    "round",
+    "saturate",
+    "select",
+    "sign",
+    "sin",
+    "sinh",
+    "smoothstep",
+    "sqrt",
+    "step",
+    "storageBarrier",
+    "tan",
+    "tanh",
+    "transpose",
+    "trunc",
+    "unpack2x16float",
+    "unpack2x16snorm",
+    "unpack2x16unorm",
+    "unpack4x8snorm",
+    "unpack4x8unorm",
+    "workgroupBarrier",
+    "workgroupUniformLoad",
+    "textureDimensions",
+    "textureGather",
+    "textureGatherCompare",
+    "textureNumLayers",
+    "textureNumLevels",
+    "textureNumSamples",
+    "textureSample",
+    "textureSampleBias",
+    "textureSampleCompare",
+    "textureSampleCompareLevel",
+    "textureSampleGrad",
+    "textureSampleLevel",
+    "textureSampleBaseClampToEdge",
+    "textureStore",
+    "textureLoad",
+    "atomicLoad",
+    "atomicStore",
+    "atomicAdd",
+    "atomicSub",
+    "atomicMax",
+    "atomicMin",
+    "atomicAnd",
+    "atomicOr",
+    "atomicXor",
+    "atomicExchange",
+    "atomicCompareExchangeWeak",
+    "_tint_materialize",
+};
+
+}  // namespace tint::builtin
+// \endcond
+
+#endif  // SRC_TINT_BUILTIN_FUNCTION_H_
diff --git a/src/tint/builtin/function.h.tmpl b/src/tint/builtin/function.h.tmpl
new file mode 100644
index 0000000..d9109bf
--- /dev/null
+++ b/src/tint/builtin/function.h.tmpl
@@ -0,0 +1,63 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate function.h
+
+To update the generated file, run:
+    ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+#ifndef SRC_TINT_BUILTIN_FUNCTION_H_
+#define SRC_TINT_BUILTIN_FUNCTION_H_
+
+#include <string>
+
+#include "src/tint/utils/string_stream.h"
+
+// \cond DO_NOT_DOCUMENT
+namespace tint::builtin {
+
+/// Enumerator of all builtin functions
+enum class Function {
+    kNone = -1,
+{{- range Sem.Builtins }}
+    k{{PascalCase .Name}},
+{{- end }}
+};
+
+/// Matches the Function by name
+/// @param name the builtin name to parse
+/// @returns the parsed Function, or Function::kNone if `name` did not
+/// match any builtin function.
+Function ParseFunction(const std::string& name);
+
+/// @returns the name of the builtin function type. The spelling, including
+/// case, matches the name in the WGSL spec.
+const char* str(Function i);
+
+/// Emits the name of the builtin function type. The spelling, including case,
+/// matches the name in the WGSL spec.
+utils::StringStream& operator<<(utils::StringStream& out, Function i);
+
+/// All builtin functions
+constexpr Function kFunctions[] = {
+{{- range Sem.Builtins }}
+    Function::k{{PascalCase .Name}},
+{{- end }}
+};
+
+/// All builtin function names
+constexpr const char* kFunctionStrings[] = {
+{{- range Sem.Builtins }}
+    "{{.Name}}",
+{{- end }}
+};
+
+}  // namespace tint::builtin
+// \endcond
+
+#endif  // SRC_TINT_BUILTIN_FUNCTION_H_
diff --git a/src/tint/castable.h b/src/tint/castable.h
index d6597fc..71e3ab8 100644
--- a/src/tint/castable.h
+++ b/src/tint/castable.h
@@ -21,9 +21,7 @@
 #include <utility>
 
 #include "src/tint/traits.h"
-#include "src/tint/utils/bitcast.h"
 #include "src/tint/utils/crc32.h"
-#include "src/tint/utils/defer.h"
 
 #if defined(__clang__)
 /// Temporarily disable certain warnings when using Castable API
@@ -532,280 +530,6 @@
 template <typename... TYPES>
 using CastableCommonBase = detail::CastableCommonBase<TYPES...>;
 
-/// Default can be used as the default case for a Switch(), when all previous cases failed to match.
-///
-/// Example:
-/// ```
-/// Switch(object,
-///     [&](TypeA*) { /* ... */ },
-///     [&](TypeB*) { /* ... */ },
-///     [&](Default) { /* If not TypeA or TypeB */ });
-/// ```
-struct Default {};
-
-namespace detail {
-
-/// Evaluates to the Switch case type being matched by the switch case function `FN`.
-/// @note does not handle the Default case
-/// @see Switch().
-template <typename FN>
-using SwitchCaseType = std::remove_pointer_t<traits::ParameterType<std::remove_reference_t<FN>, 0>>;
-
-/// Evaluates to true if the function `FN` has the signature of a Default case in a Switch().
-/// @see Switch().
-template <typename FN>
-inline constexpr bool IsDefaultCase =
-    std::is_same_v<traits::ParameterType<std::remove_reference_t<FN>, 0>, Default>;
-
-/// Searches the list of Switch cases for a Default case, returning the index of the Default case.
-/// If the a Default case is not found in the tuple, then -1 is returned.
-template <typename TUPLE, std::size_t START_IDX = 0>
-constexpr int IndexOfDefaultCase() {
-    if constexpr (START_IDX < std::tuple_size_v<TUPLE>) {
-        return IsDefaultCase<std::tuple_element_t<START_IDX, TUPLE>>
-                   ? static_cast<int>(START_IDX)
-                   : IndexOfDefaultCase<TUPLE, START_IDX + 1>();
-    } else {
-        return -1;
-    }
-}
-
-/// The implementation of Switch() for non-Default cases.
-/// Switch splits the cases into two a low and high block of cases, and quickly rules out blocks
-/// that cannot match by comparing the HashCode of the object and the cases in the block. If a block
-/// of cases may match the given object's type, then that block is split into two, and the process
-/// recurses. When NonDefaultCases() is called with a single case, then As<> will be used to
-/// dynamically cast to the case type and if the cast succeeds, then the case handler is called.
-/// @returns true if a case handler was found, otherwise false.
-template <typename T, typename RETURN_TYPE, typename... CASES>
-inline bool NonDefaultCases([[maybe_unused]] T* object,
-                            const TypeInfo* type,
-                            [[maybe_unused]] RETURN_TYPE* result,
-                            std::tuple<CASES...>&& cases) {
-    using Cases = std::tuple<CASES...>;
-
-    static constexpr bool kHasReturnType = !std::is_same_v<RETURN_TYPE, void>;
-    static constexpr size_t kNumCases = sizeof...(CASES);
-
-    if constexpr (kNumCases == 0) {
-        // No cases. Nothing to do.
-        return false;
-    } else if constexpr (kNumCases == 1) {  // NOLINT: cpplint doesn't understand
-                                            // `else if constexpr`
-        // Single case.
-        using CaseFunc = std::tuple_element_t<0, Cases>;
-        static_assert(!IsDefaultCase<CaseFunc>, "NonDefaultCases called with a Default case");
-        // Attempt to dynamically cast the object to the handler type. If that succeeds, call the
-        // case handler with the cast object.
-        using CaseType = SwitchCaseType<CaseFunc>;
-        if (type->Is<CaseType>()) {
-            auto* ptr = static_cast<CaseType*>(object);
-            if constexpr (kHasReturnType) {
-                new (result) RETURN_TYPE(static_cast<RETURN_TYPE>(std::get<0>(cases)(ptr)));
-            } else {
-                std::get<0>(cases)(ptr);
-            }
-            return true;
-        }
-        return false;
-    } else {
-        // Multiple cases.
-        // Check the hashcode bits to see if there's any possibility of a case matching in these
-        // cases. If there isn't, we can skip all these cases.
-        if (MaybeAnyOf(TypeInfo::CombinedHashCodeOf<SwitchCaseType<CASES>...>(),
-                       type->full_hashcode)) {
-            // Split the cases into two, and recurse.
-            constexpr size_t kMid = kNumCases / 2;
-            return NonDefaultCases(object, type, result, traits::Slice<0, kMid>(cases)) ||
-                   NonDefaultCases(object, type, result,
-                                   traits::Slice<kMid, kNumCases - kMid>(cases));
-        } else {
-            return false;
-        }
-    }
-}
-
-/// The implementation of Switch() for all cases.
-/// @see NonDefaultCases
-template <typename T, typename RETURN_TYPE, typename... CASES>
-inline void SwitchCases(T* object, RETURN_TYPE* result, std::tuple<CASES...>&& cases) {
-    using Cases = std::tuple<CASES...>;
-
-    static constexpr int kDefaultIndex = detail::IndexOfDefaultCase<Cases>();
-    static constexpr bool kHasDefaultCase = kDefaultIndex >= 0;
-    static constexpr bool kHasReturnType = !std::is_same_v<RETURN_TYPE, void>;
-
-    // Static assertions
-    static constexpr bool kDefaultIsOK =
-        kDefaultIndex == -1 || kDefaultIndex == static_cast<int>(std::tuple_size_v<Cases> - 1);
-    static constexpr bool kReturnIsOK =
-        kHasDefaultCase || !kHasReturnType || std::is_constructible_v<RETURN_TYPE>;
-    static_assert(kDefaultIsOK, "Default case must be last in Switch()");
-    static_assert(kReturnIsOK,
-                  "Switch() requires either a Default case or a return type that is either void or "
-                  "default-constructable");
-
-    // If the static asserts have fired, don't bother spewing more errors below
-    static constexpr bool kAllOK = kDefaultIsOK && kReturnIsOK;
-    if constexpr (kAllOK) {
-        if (object) {
-            auto* type = &object->TypeInfo();
-            if constexpr (kHasDefaultCase) {
-                // Evaluate non-default cases.
-                if (!detail::NonDefaultCases<T>(object, type, result,
-                                                traits::Slice<0, kDefaultIndex>(cases))) {
-                    // Nothing matched. Evaluate default case.
-                    if constexpr (kHasReturnType) {
-                        new (result) RETURN_TYPE(
-                            static_cast<RETURN_TYPE>(std::get<kDefaultIndex>(cases)({})));
-                    } else {
-                        std::get<kDefaultIndex>(cases)({});
-                    }
-                }
-            } else {
-                if (!detail::NonDefaultCases<T>(object, type, result, std::move(cases))) {
-                    // Nothing matched. No default case.
-                    if constexpr (kHasReturnType) {
-                        new (result) RETURN_TYPE();
-                    }
-                }
-            }
-        } else {
-            // Object is nullptr, so no cases can match
-            if constexpr (kHasDefaultCase) {
-                // Evaluate default case.
-                if constexpr (kHasReturnType) {
-                    new (result)
-                        RETURN_TYPE(static_cast<RETURN_TYPE>(std::get<kDefaultIndex>(cases)({})));
-                } else {
-                    std::get<kDefaultIndex>(cases)({});
-                }
-            } else {
-                // No default case, no case can match.
-                if constexpr (kHasReturnType) {
-                    new (result) RETURN_TYPE();
-                }
-            }
-        }
-    }
-}
-
-/// Resolves to T if T is not nullptr_t, otherwise resolves to Ignore.
-template <typename T>
-using NullptrToIgnore = std::conditional_t<std::is_same_v<T, std::nullptr_t>, Ignore, T>;
-
-/// Resolves to `const TYPE` if any of `CASE_RETURN_TYPES` are const or pointer-to-const, otherwise
-/// resolves to TYPE.
-template <typename TYPE, typename... CASE_RETURN_TYPES>
-using PropagateReturnConst = std::conditional_t<
-    // Are any of the pointer-stripped types const?
-    (std::is_const_v<std::remove_pointer_t<CASE_RETURN_TYPES>> || ...),
-    const TYPE,  // Yes: Apply const to TYPE
-    TYPE>;       // No:  Passthrough
-
-/// SwitchReturnTypeImpl is the implementation of SwitchReturnType
-template <bool IS_CASTABLE, typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
-struct SwitchReturnTypeImpl;
-
-/// SwitchReturnTypeImpl specialization for non-castable case types and an explicitly specified
-/// return type.
-template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
-struct SwitchReturnTypeImpl</*IS_CASTABLE*/ false, REQUESTED_TYPE, CASE_RETURN_TYPES...> {
-    /// Resolves to `REQUESTED_TYPE`
-    using type = REQUESTED_TYPE;
-};
-
-/// SwitchReturnTypeImpl specialization for non-castable case types and an inferred return type.
-template <typename... CASE_RETURN_TYPES>
-struct SwitchReturnTypeImpl</*IS_CASTABLE*/ false, Infer, CASE_RETURN_TYPES...> {
-    /// Resolves to the common type for all the cases return types.
-    using type = std::common_type_t<CASE_RETURN_TYPES...>;
-};
-
-/// SwitchReturnTypeImpl specialization for castable case types and an explicitly specified return
-/// type.
-template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
-struct SwitchReturnTypeImpl</*IS_CASTABLE*/ true, REQUESTED_TYPE, CASE_RETURN_TYPES...> {
-  public:
-    /// Resolves to `const REQUESTED_TYPE*` or `REQUESTED_TYPE*`
-    using type = PropagateReturnConst<std::remove_pointer_t<REQUESTED_TYPE>, CASE_RETURN_TYPES...>*;
-};
-
-/// SwitchReturnTypeImpl specialization for castable case types and an inferred return type.
-template <typename... CASE_RETURN_TYPES>
-struct SwitchReturnTypeImpl</*IS_CASTABLE*/ true, Infer, CASE_RETURN_TYPES...> {
-  private:
-    using InferredType =
-        CastableCommonBase<detail::NullptrToIgnore<std::remove_pointer_t<CASE_RETURN_TYPES>>...>;
-
-  public:
-    /// `const T*` or `T*`, where T is the common base type for all the castable case types.
-    using type = PropagateReturnConst<InferredType, CASE_RETURN_TYPES...>*;
-};
-
-/// Resolves to the return type for a Switch() with the requested return type `REQUESTED_TYPE` and
-/// case statement return types. If `REQUESTED_TYPE` is Infer then the return type will be inferred
-/// from the case return types.
-template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
-using SwitchReturnType = typename SwitchReturnTypeImpl<
-    IsCastable<NullptrToIgnore<std::remove_pointer_t<CASE_RETURN_TYPES>>...>,
-    REQUESTED_TYPE,
-    CASE_RETURN_TYPES...>::type;
-
-}  // namespace detail
-
-/// Switch is used to dispatch one of the provided callback case handler functions based on the type
-/// of `object` and the parameter type of the case handlers. Switch will sequentially check the type
-/// of `object` against each of the switch case handler functions, and will invoke the first case
-/// handler function which has a parameter type that matches the object type. When a case handler is
-/// matched, it will be called with the single argument of `object` cast to the case handler's
-/// parameter type. Switch will invoke at most one case handler. Each of the case functions must
-/// have the signature `R(T*)` or `R(const T*)`, where `T` is the type matched by that case and `R`
-/// is the return type, consistent across all case handlers.
-///
-/// An optional default case function with the signature `R(Default)` can be used as the last case.
-/// This default case will be called if all previous cases failed to match.
-///
-/// If `object` is nullptr and a default case is provided, then the default case will be called. If
-/// `object` is nullptr and no default case is provided, then no cases will be called.
-///
-/// Example:
-/// ```
-/// Switch(object,
-///     [&](TypeA*) { /* ... */ },
-///     [&](TypeB*) { /* ... */ });
-///
-/// Switch(object,
-///     [&](TypeA*) { /* ... */ },
-///     [&](TypeB*) { /* ... */ },
-///     [&](Default) { /* Called if object is not TypeA or TypeB */ });
-/// ```
-///
-/// @param object the object who's type is used to
-/// @param cases the switch cases
-/// @return the value returned by the called case. If no cases matched, then the zero value for the
-/// consistent case type.
-template <typename RETURN_TYPE = detail::Infer, typename T = CastableBase, typename... CASES>
-inline auto Switch(T* object, CASES&&... cases) {
-    using ReturnType = detail::SwitchReturnType<RETURN_TYPE, traits::ReturnType<CASES>...>;
-    static constexpr bool kHasReturnType = !std::is_same_v<ReturnType, void>;
-
-    if constexpr (kHasReturnType) {
-        // Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
-        struct alignas(alignof(ReturnType)) ReturnStorage {
-            uint8_t data[sizeof(ReturnType)];
-        };
-        ReturnStorage storage;
-        auto* res = utils::Bitcast<ReturnType*>(&storage);
-        TINT_DEFER(res->~ReturnType());
-        detail::SwitchCases(object, res, std::forward_as_tuple(std::forward<CASES>(cases)...));
-        return *res;
-    } else {
-        detail::SwitchCases<T, void>(object, nullptr,
-                                     std::forward_as_tuple(std::forward<CASES>(cases)...));
-    }
-}
-
 }  // namespace tint
 
 TINT_CASTABLE_POP_DISABLE_WARNINGS();
diff --git a/src/tint/castable_test.cc b/src/tint/castable_test.cc
index c452c9b..57bd904 100644
--- a/src/tint/castable_test.cc
+++ b/src/tint/castable_test.cc
@@ -20,6 +20,7 @@
 #include "gtest/gtest.h"
 
 namespace tint {
+namespace {
 
 struct Animal : public tint::Castable<Animal> {};
 struct Amphibian : public tint::Castable<Amphibian, Animal> {};
@@ -31,8 +32,6 @@
 struct Gecko : public tint::Castable<Gecko, Lizard> {};
 struct Iguana : public tint::Castable<Iguana, Lizard> {};
 
-namespace {
-
 TEST(CastableBase, Is) {
     std::unique_ptr<CastableBase> frog = std::make_unique<Frog>();
     std::unique_ptr<CastableBase> bear = std::make_unique<Bear>();
@@ -230,512 +229,6 @@
     ASSERT_EQ(gecko->As<Reptile>(), static_cast<Reptile*>(gecko.get()));
 }
 
-TEST(Castable, SwitchNoDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        bool frog_matched_amphibian = false;
-        Switch(
-            frog.get(),  //
-            [&](Reptile*) { FAIL() << "frog is not reptile"; },
-            [&](Mammal*) { FAIL() << "frog is not mammal"; },
-            [&](Amphibian* amphibian) {
-                EXPECT_EQ(amphibian, frog.get());
-                frog_matched_amphibian = true;
-            });
-        EXPECT_TRUE(frog_matched_amphibian);
-    }
-    {
-        bool bear_matched_mammal = false;
-        Switch(
-            bear.get(),  //
-            [&](Reptile*) { FAIL() << "bear is not reptile"; },
-            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
-            [&](Mammal* mammal) {
-                EXPECT_EQ(mammal, bear.get());
-                bear_matched_mammal = true;
-            });
-        EXPECT_TRUE(bear_matched_mammal);
-    }
-    {
-        bool gecko_matched_reptile = false;
-        Switch(
-            gecko.get(),  //
-            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
-            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
-            [&](Reptile* reptile) {
-                EXPECT_EQ(reptile, gecko.get());
-                gecko_matched_reptile = true;
-            });
-        EXPECT_TRUE(gecko_matched_reptile);
-    }
-}
-
-TEST(Castable, SwitchWithUnusedDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        bool frog_matched_amphibian = false;
-        Switch(
-            frog.get(),  //
-            [&](Reptile*) { FAIL() << "frog is not reptile"; },
-            [&](Mammal*) { FAIL() << "frog is not mammal"; },
-            [&](Amphibian* amphibian) {
-                EXPECT_EQ(amphibian, frog.get());
-                frog_matched_amphibian = true;
-            },
-            [&](Default) { FAIL() << "default should not have been selected"; });
-        EXPECT_TRUE(frog_matched_amphibian);
-    }
-    {
-        bool bear_matched_mammal = false;
-        Switch(
-            bear.get(),  //
-            [&](Reptile*) { FAIL() << "bear is not reptile"; },
-            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
-            [&](Mammal* mammal) {
-                EXPECT_EQ(mammal, bear.get());
-                bear_matched_mammal = true;
-            },
-            [&](Default) { FAIL() << "default should not have been selected"; });
-        EXPECT_TRUE(bear_matched_mammal);
-    }
-    {
-        bool gecko_matched_reptile = false;
-        Switch(
-            gecko.get(),  //
-            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
-            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
-            [&](Reptile* reptile) {
-                EXPECT_EQ(reptile, gecko.get());
-                gecko_matched_reptile = true;
-            },
-            [&](Default) { FAIL() << "default should not have been selected"; });
-        EXPECT_TRUE(gecko_matched_reptile);
-    }
-}
-
-TEST(Castable, SwitchDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        bool frog_matched_default = false;
-        Switch(
-            frog.get(),  //
-            [&](Reptile*) { FAIL() << "frog is not reptile"; },
-            [&](Mammal*) { FAIL() << "frog is not mammal"; },
-            [&](Default) { frog_matched_default = true; });
-        EXPECT_TRUE(frog_matched_default);
-    }
-    {
-        bool bear_matched_default = false;
-        Switch(
-            bear.get(),  //
-            [&](Reptile*) { FAIL() << "bear is not reptile"; },
-            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
-            [&](Default) { bear_matched_default = true; });
-        EXPECT_TRUE(bear_matched_default);
-    }
-    {
-        bool gecko_matched_default = false;
-        Switch(
-            gecko.get(),  //
-            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
-            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
-            [&](Default) { gecko_matched_default = true; });
-        EXPECT_TRUE(gecko_matched_default);
-    }
-}
-
-TEST(Castable, SwitchMatchFirst) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    {
-        bool frog_matched_animal = false;
-        Switch(
-            frog.get(),
-            [&](Animal* animal) {
-                EXPECT_EQ(animal, frog.get());
-                frog_matched_animal = true;
-            },
-            [&](Amphibian*) { FAIL() << "animal should have been matched first"; });
-        EXPECT_TRUE(frog_matched_animal);
-    }
-    {
-        bool frog_matched_amphibian = false;
-        Switch(
-            frog.get(),
-            [&](Amphibian* amphibain) {
-                EXPECT_EQ(amphibain, frog.get());
-                frog_matched_amphibian = true;
-            },
-            [&](Animal*) { FAIL() << "amphibian should have been matched first"; });
-        EXPECT_TRUE(frog_matched_amphibian);
-    }
-}
-
-TEST(Castable, SwitchReturnValueWithDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        const char* result = Switch(
-            frog.get(),                              //
-            [](Mammal*) { return "mammal"; },        //
-            [](Amphibian*) { return "amphibian"; },  //
-            [](Default) { return "unknown"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(std::string(result), "amphibian");
-    }
-    {
-        const char* result = Switch(
-            bear.get(),                              //
-            [](Mammal*) { return "mammal"; },        //
-            [](Amphibian*) { return "amphibian"; },  //
-            [](Default) { return "unknown"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(std::string(result), "mammal");
-    }
-    {
-        const char* result = Switch(
-            gecko.get(),                             //
-            [](Mammal*) { return "mammal"; },        //
-            [](Amphibian*) { return "amphibian"; },  //
-            [](Default) { return "unknown"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(std::string(result), "unknown");
-    }
-}
-
-TEST(Castable, SwitchReturnValueWithoutDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        const char* result = Switch(
-            frog.get(),                        //
-            [](Mammal*) { return "mammal"; },  //
-            [](Amphibian*) { return "amphibian"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(std::string(result), "amphibian");
-    }
-    {
-        const char* result = Switch(
-            bear.get(),                        //
-            [](Mammal*) { return "mammal"; },  //
-            [](Amphibian*) { return "amphibian"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(std::string(result), "mammal");
-    }
-    {
-        auto* result = Switch(
-            gecko.get(),                       //
-            [](Mammal*) { return "mammal"; },  //
-            [](Amphibian*) { return "amphibian"; });
-        static_assert(std::is_same_v<decltype(result), const char*>);
-        EXPECT_EQ(result, nullptr);
-    }
-}
-
-TEST(Castable, SwitchInferPODReturnTypeWithDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto result = Switch(
-            frog.get(),                       //
-            [](Mammal*) { return 1; },        //
-            [](Amphibian*) { return 2.0f; },  //
-            [](Default) { return 3.0; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 2.0);
-    }
-    {
-        auto result = Switch(
-            bear.get(),                       //
-            [](Mammal*) { return 1.0; },      //
-            [](Amphibian*) { return 2.0f; },  //
-            [](Default) { return 3; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 1.0);
-    }
-    {
-        auto result = Switch(
-            gecko.get(),                   //
-            [](Mammal*) { return 1.0f; },  //
-            [](Amphibian*) { return 2; },  //
-            [](Default) { return 3.0; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 3.0);
-    }
-}
-
-TEST(Castable, SwitchInferPODReturnTypeWithoutDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto result = Switch(
-            frog.get(),                 //
-            [](Mammal*) { return 1; },  //
-            [](Amphibian*) { return 2.0f; });
-        static_assert(std::is_same_v<decltype(result), float>);
-        EXPECT_EQ(result, 2.0f);
-    }
-    {
-        auto result = Switch(
-            bear.get(),                    //
-            [](Mammal*) { return 1.0f; },  //
-            [](Amphibian*) { return 2; });
-        static_assert(std::is_same_v<decltype(result), float>);
-        EXPECT_EQ(result, 1.0f);
-    }
-    {
-        auto result = Switch(
-            gecko.get(),                  //
-            [](Mammal*) { return 1.0; },  //
-            [](Amphibian*) { return 2.0f; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 0.0);
-    }
-}
-
-TEST(Castable, SwitchInferCastableReturnTypeWithDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto* result = Switch(
-            frog.get(),                          //
-            [](Mammal* p) { return p; },         //
-            [](Amphibian*) { return nullptr; },  //
-            [](Default) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), Mammal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-    {
-        auto* result = Switch(
-            bear.get(),                   //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian* p) { return const_cast<const Amphibian*>(p); },
-            [](Default) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), const Animal*>);
-        EXPECT_EQ(result, bear.get());
-    }
-    {
-        auto* result = Switch(
-            gecko.get(),                     //
-            [](Mammal* p) { return p; },     //
-            [](Amphibian* p) { return p; },  //
-            [](Default) -> CastableBase* { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), CastableBase*>);
-        EXPECT_EQ(result, nullptr);
-    }
-}
-
-TEST(Castable, SwitchInferCastableReturnTypeWithoutDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto* result = Switch(
-            frog.get(),                   //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian*) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), Mammal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-    {
-        auto* result = Switch(
-            bear.get(),                                                     //
-            [](Mammal* p) { return p; },                                    //
-            [](Amphibian* p) { return const_cast<const Amphibian*>(p); });  //
-        static_assert(std::is_same_v<decltype(result), const Animal*>);
-        EXPECT_EQ(result, bear.get());
-    }
-    {
-        auto* result = Switch(
-            gecko.get(),                  //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian* p) { return p; });
-        static_assert(std::is_same_v<decltype(result), Animal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-}
-
-TEST(Castable, SwitchExplicitPODReturnTypeWithDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto result = Switch<double>(
-            frog.get(),                       //
-            [](Mammal*) { return 1; },        //
-            [](Amphibian*) { return 2.0f; },  //
-            [](Default) { return 3.0; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 2.0f);
-    }
-    {
-        auto result = Switch<double>(
-            bear.get(),                    //
-            [](Mammal*) { return 1; },     //
-            [](Amphibian*) { return 2; },  //
-            [](Default) { return 3; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 1.0f);
-    }
-    {
-        auto result = Switch<double>(
-            gecko.get(),                      //
-            [](Mammal*) { return 1.0f; },     //
-            [](Amphibian*) { return 2.0f; },  //
-            [](Default) { return 3.0f; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 3.0f);
-    }
-}
-
-TEST(Castable, SwitchExplicitPODReturnTypeWithoutDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto result = Switch<double>(
-            frog.get(),                 //
-            [](Mammal*) { return 1; },  //
-            [](Amphibian*) { return 2.0f; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 2.0f);
-    }
-    {
-        auto result = Switch<double>(
-            bear.get(),                    //
-            [](Mammal*) { return 1.0f; },  //
-            [](Amphibian*) { return 2; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 1.0f);
-    }
-    {
-        auto result = Switch<double>(
-            gecko.get(),                  //
-            [](Mammal*) { return 1.0; },  //
-            [](Amphibian*) { return 2.0f; });
-        static_assert(std::is_same_v<decltype(result), double>);
-        EXPECT_EQ(result, 0.0);
-    }
-}
-
-TEST(Castable, SwitchExplicitCastableReturnTypeWithDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto* result = Switch<Animal>(
-            frog.get(),                          //
-            [](Mammal* p) { return p; },         //
-            [](Amphibian*) { return nullptr; },  //
-            [](Default) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), Animal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-    {
-        auto* result = Switch<CastableBase>(
-            bear.get(),                   //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian* p) { return const_cast<const Amphibian*>(p); },
-            [](Default) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), const CastableBase*>);
-        EXPECT_EQ(result, bear.get());
-    }
-    {
-        auto* result = Switch<const Animal>(
-            gecko.get(),                     //
-            [](Mammal* p) { return p; },     //
-            [](Amphibian* p) { return p; },  //
-            [](Default) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), const Animal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-}
-
-TEST(Castable, SwitchExplicitCastableReturnTypeWithoutDefault) {
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
-    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
-    {
-        auto* result = Switch<Animal>(
-            frog.get(),                   //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian*) { return nullptr; });
-        static_assert(std::is_same_v<decltype(result), Animal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-    {
-        auto* result = Switch<CastableBase>(
-            bear.get(),                                                     //
-            [](Mammal* p) { return p; },                                    //
-            [](Amphibian* p) { return const_cast<const Amphibian*>(p); });  //
-        static_assert(std::is_same_v<decltype(result), const CastableBase*>);
-        EXPECT_EQ(result, bear.get());
-    }
-    {
-        auto* result = Switch<const Animal*>(
-            gecko.get(),                  //
-            [](Mammal* p) { return p; },  //
-            [](Amphibian* p) { return p; });
-        static_assert(std::is_same_v<decltype(result), const Animal*>);
-        EXPECT_EQ(result, nullptr);
-    }
-}
-
-TEST(Castable, SwitchNull) {
-    Animal* null = nullptr;
-    Switch(
-        null,  //
-        [&](Amphibian*) { FAIL() << "should not be called"; },
-        [&](Animal*) { FAIL() << "should not be called"; });
-}
-
-TEST(Castable, SwitchNullNoDefault) {
-    Animal* null = nullptr;
-    bool default_called = false;
-    Switch(
-        null,  //
-        [&](Amphibian*) { FAIL() << "should not be called"; },
-        [&](Animal*) { FAIL() << "should not be called"; },
-        [&](Default) { default_called = true; });
-    EXPECT_TRUE(default_called);
-}
-
-TEST(Castable, SwitchReturnNoDefaultInitializer) {
-    struct Object {
-        explicit Object(int v) : value(v) {}
-        int value;
-    };
-
-    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
-    {
-        auto result = Switch(
-            frog.get(),                            //
-            [](Mammal*) { return Object(1); },     //
-            [](Amphibian*) { return Object(2); },  //
-            [](Default) { return Object(3); });
-        static_assert(std::is_same_v<decltype(result), Object>);
-        EXPECT_EQ(result.value, 2);
-    }
-    {
-        auto result = Switch(
-            frog.get(),                         //
-            [](Mammal*) { return Object(1); },  //
-            [](Default) { return Object(3); });
-        static_assert(std::is_same_v<decltype(result), Object>);
-        EXPECT_EQ(result.value, 3);
-    }
-}
-
 // IsCastable static tests
 static_assert(IsCastable<CastableBase>);
 static_assert(IsCastable<Animal>);
diff --git a/src/tint/cmd/BUILD.gn b/src/tint/cmd/BUILD.gn
index b4ff6d5..946bd36 100644
--- a/src/tint/cmd/BUILD.gn
+++ b/src/tint/cmd/BUILD.gn
@@ -17,6 +17,8 @@
 
 source_set("tint_cmd_helper") {
   sources = [
+    "generate_external_texture_bindings.cc",
+    "generate_external_texture_bindings.h",
     "helper.cc",
     "helper.h",
   ]
diff --git a/src/tint/cmd/CMakeLists.txt b/src/tint/cmd/CMakeLists.txt
index 6da9701..142595b 100644
--- a/src/tint/cmd/CMakeLists.txt
+++ b/src/tint/cmd/CMakeLists.txt
@@ -15,6 +15,8 @@
 ## Tint executable
 add_executable(tint "")
 target_sources(tint PRIVATE
+  "generate_external_texture_bindings.cc"
+  "generate_external_texture_bindings.h"
   "helper.cc"
   "helper.h"
   "main.cc"
diff --git a/src/tint/writer/generate_external_texture_bindings.cc b/src/tint/cmd/generate_external_texture_bindings.cc
similarity index 82%
rename from src/tint/writer/generate_external_texture_bindings.cc
rename to src/tint/cmd/generate_external_texture_bindings.cc
index 6e5daf0..1b6ca74 100644
--- a/src/tint/writer/generate_external_texture_bindings.cc
+++ b/src/tint/cmd/generate_external_texture_bindings.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/tint/writer/generate_external_texture_bindings.h"
+#include "src/tint/cmd/generate_external_texture_bindings.h"
 
 #include <algorithm>
 #include <unordered_map>
@@ -20,12 +20,13 @@
 
 #include "src/tint/ast/module.h"
 #include "src/tint/program.h"
+#include "src/tint/sem/binding_point.h"
 #include "src/tint/sem/variable.h"
 #include "src/tint/type/external_texture.h"
 
-namespace tint::writer {
+namespace tint::cmd {
 
-transform::MultiplanarExternalTexture::BindingsMap GenerateExternalTextureBindings(
+writer::ExternalTextureOptions::BindingsMap GenerateExternalTextureBindings(
     const Program* program) {
     // TODO(tint:1491): Use Inspector once we can get binding info for all
     // variables, not just those referenced by entry points.
@@ -45,15 +46,17 @@
         }
     }
 
-    transform::MultiplanarExternalTexture::BindingsMap new_bindings_map;
+    writer::ExternalTextureOptions::BindingsMap new_bindings_map;
     for (auto bp : ext_tex_bps) {
         uint32_t g = bp.group;
         uint32_t& next_num = group_to_next_binding_number[g];
         auto new_bps =
-            transform::MultiplanarExternalTexture::BindingPoints{{g, next_num++}, {g, next_num++}};
+            writer::ExternalTextureOptions::BindingPoints{{g, next_num++}, {g, next_num++}};
+
         new_bindings_map[bp] = new_bps;
     }
+
     return new_bindings_map;
 }
 
-}  // namespace tint::writer
+}  // namespace tint::cmd
diff --git a/src/tint/cmd/generate_external_texture_bindings.h b/src/tint/cmd/generate_external_texture_bindings.h
new file mode 100644
index 0000000..c6a842d
--- /dev/null
+++ b/src/tint/cmd/generate_external_texture_bindings.h
@@ -0,0 +1,26 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_CMD_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
+#define SRC_TINT_CMD_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
+
+#include "tint/tint.h"
+
+namespace tint::cmd {
+
+writer::ExternalTextureOptions::BindingsMap GenerateExternalTextureBindings(const Program* program);
+
+}  // namespace tint::cmd
+
+#endif  // SRC_TINT_CMD_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
diff --git a/src/tint/writer/generate_external_texture_bindings_test.cc b/src/tint/cmd/generate_external_texture_bindings_test.cc
similarity index 88%
rename from src/tint/writer/generate_external_texture_bindings_test.cc
rename to src/tint/cmd/generate_external_texture_bindings_test.cc
index d6b22ac..2c19675 100644
--- a/src/tint/writer/generate_external_texture_bindings_test.cc
+++ b/src/tint/cmd/generate_external_texture_bindings_test.cc
@@ -15,10 +15,11 @@
 #include <utility>
 
 #include "gtest/gtest.h"
+#include "src/tint/cmd/generate_external_texture_bindings.h"
 #include "src/tint/program_builder.h"
-#include "src/tint/writer/generate_external_texture_bindings.h"
+#include "src/tint/writer/binding_point.h"
 
-namespace tint::writer {
+namespace tint::cmd {
 namespace {
 
 using namespace tint::number_suffixes;  // NOLINT
@@ -45,7 +46,7 @@
     auto bindings = GenerateExternalTextureBindings(&program);
     ASSERT_EQ(bindings.size(), 1u);
 
-    auto to = bindings[transform::BindingPoint{0, 0}];
+    auto to = bindings[writer::BindingPoint{0, 0}];
     ASSERT_EQ(to.plane_1.group, 0u);
     ASSERT_EQ(to.params.group, 0u);
     ASSERT_EQ(to.plane_1.binding, 1u);
@@ -62,13 +63,13 @@
     auto bindings = GenerateExternalTextureBindings(&program);
     ASSERT_EQ(bindings.size(), 2u);
 
-    auto to0 = bindings[transform::BindingPoint{0, 0}];
+    auto to0 = bindings[writer::BindingPoint{0, 0}];
     ASSERT_EQ(to0.plane_1.group, 0u);
     ASSERT_EQ(to0.params.group, 0u);
     ASSERT_EQ(to0.plane_1.binding, 2u);
     ASSERT_EQ(to0.params.binding, 3u);
 
-    auto to1 = bindings[transform::BindingPoint{0, 1}];
+    auto to1 = bindings[writer::BindingPoint{0, 1}];
     ASSERT_EQ(to1.plane_1.group, 0u);
     ASSERT_EQ(to1.params.group, 0u);
     ASSERT_EQ(to1.plane_1.binding, 4u);
@@ -85,13 +86,13 @@
     auto bindings = GenerateExternalTextureBindings(&program);
     ASSERT_EQ(bindings.size(), 2u);
 
-    auto to0 = bindings[transform::BindingPoint{0, 0}];
+    auto to0 = bindings[writer::BindingPoint{0, 0}];
     ASSERT_EQ(to0.plane_1.group, 0u);
     ASSERT_EQ(to0.params.group, 0u);
     ASSERT_EQ(to0.plane_1.binding, 1u);
     ASSERT_EQ(to0.params.binding, 2u);
 
-    auto to1 = bindings[transform::BindingPoint{1, 0}];
+    auto to1 = bindings[writer::BindingPoint{1, 0}];
     ASSERT_EQ(to1.plane_1.group, 1u);
     ASSERT_EQ(to1.params.group, 1u);
     ASSERT_EQ(to1.plane_1.binding, 1u);
@@ -111,13 +112,13 @@
     auto bindings = GenerateExternalTextureBindings(&program);
     ASSERT_EQ(bindings.size(), 2u);
 
-    auto to0 = bindings[transform::BindingPoint{0, 1}];
+    auto to0 = bindings[writer::BindingPoint{0, 1}];
     ASSERT_EQ(to0.plane_1.group, 0u);
     ASSERT_EQ(to0.params.group, 0u);
     ASSERT_EQ(to0.plane_1.binding, 5u);
     ASSERT_EQ(to0.params.binding, 6u);
 
-    auto to1 = bindings[transform::BindingPoint{0, 3}];
+    auto to1 = bindings[writer::BindingPoint{0, 3}];
     ASSERT_EQ(to1.plane_1.group, 0u);
     ASSERT_EQ(to1.params.group, 0u);
     ASSERT_EQ(to1.plane_1.binding, 7u);
@@ -125,4 +126,4 @@
 }
 
 }  // namespace
-}  // namespace tint::writer
+}  // namespace tint::cmd
diff --git a/src/tint/cmd/helper.cc b/src/tint/cmd/helper.cc
index 53013fe..49b970a 100644
--- a/src/tint/cmd/helper.cc
+++ b/src/tint/cmd/helper.cc
@@ -18,7 +18,7 @@
 #include <utility>
 #include <vector>
 
-#if TINT_BUILD_SPV_WRITER
+#if TINT_BUILD_SPV_READER
 #include "spirv-tools/libspirv.hpp"
 #endif
 
diff --git a/src/tint/cmd/main.cc b/src/tint/cmd/main.cc
index 0b2aad2..898f0ac 100644
--- a/src/tint/cmd/main.cc
+++ b/src/tint/cmd/main.cc
@@ -29,11 +29,17 @@
 #include "glslang/Public/ShaderLang.h"
 #endif  // TINT_BUILD_GLSL_WRITER
 
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+#include "src/tint/writer/syntax_tree/generator.h"  // nogncheck
+
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
+
 #if TINT_BUILD_SPV_READER
 #include "spirv-tools/libspirv.hpp"
 #endif  // TINT_BUILD_SPV_READER
 
 #include "src/tint/ast/module.h"
+#include "src/tint/cmd/generate_external_texture_bindings.h"
 #include "src/tint/cmd/helper.h"
 #include "src/tint/utils/io/command.h"
 #include "src/tint/utils/string.h"
@@ -106,6 +112,10 @@
     bool dump_ir = false;
     bool dump_ir_graph = false;
 #endif  // TINT_BUILD_IR
+
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+    bool dump_syntax_tree = false;
+#endif  // TINB_BUILD_SYNTAX_TREE_WRITER
 };
 
 const char kUsage[] = R"(Usage: tint [options] <input-file>
@@ -383,6 +393,10 @@
         } else if (arg == "--dump-ir-graph") {
             opts->dump_ir_graph = true;
 #endif  // TINT_BUILD_IR
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+        } else if (arg == "--dump-ast") {
+            opts->dump_syntax_tree = true;
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
         } else if (arg == "--xcrun") {
             ++i;
             if (i >= args.size()) {
@@ -536,7 +550,8 @@
     tint::writer::spirv::Options gen_options;
     gen_options.disable_robustness = !options.enable_robustness;
     gen_options.disable_workgroup_init = options.disable_workgroup_init;
-    gen_options.generate_external_texture_bindings = true;
+    gen_options.external_texture_options.bindings_map =
+        tint::cmd::GenerateExternalTextureBindings(program);
     auto result = tint::writer::spirv::Generate(program, gen_options);
     if (!result.success) {
         tint::cmd::PrintWGSL(std::cerr, *program);
@@ -643,7 +658,8 @@
     tint::writer::msl::Options gen_options;
     gen_options.disable_robustness = !options.enable_robustness;
     gen_options.disable_workgroup_init = options.disable_workgroup_init;
-    gen_options.generate_external_texture_bindings = true;
+    gen_options.external_texture_options.bindings_map =
+        tint::cmd::GenerateExternalTextureBindings(input_program);
     auto result = tint::writer::msl::Generate(input_program, gen_options);
     if (!result.success) {
         tint::cmd::PrintWGSL(std::cerr, *program);
@@ -704,7 +720,8 @@
     tint::writer::hlsl::Options gen_options;
     gen_options.disable_robustness = !options.enable_robustness;
     gen_options.disable_workgroup_init = options.disable_workgroup_init;
-    gen_options.generate_external_texture_bindings = true;
+    gen_options.external_texture_options.bindings_map =
+        tint::cmd::GenerateExternalTextureBindings(program);
     gen_options.root_constant_binding_point = options.hlsl_root_constant_binding_point;
     auto result = tint::writer::hlsl::Generate(program, gen_options);
     if (!result.success) {
@@ -738,8 +755,8 @@
 
                 auto enable_list = program->AST().Enables();
                 bool dxc_require_16bit_types = false;
-                for (auto enable : enable_list) {
-                    if (enable->extension == tint::builtin::Extension::kF16) {
+                for (auto* enable : enable_list) {
+                    if (enable->HasExtension(tint::builtin::Extension::kF16)) {
                         dxc_require_16bit_types = true;
                         break;
                     }
@@ -843,7 +860,8 @@
     auto generate = [&](const tint::Program* prg, const std::string entry_point_name) -> bool {
         tint::writer::glsl::Options gen_options;
         gen_options.disable_robustness = !options.enable_robustness;
-        gen_options.generate_external_texture_bindings = true;
+        gen_options.external_texture_options.bindings_map =
+            tint::cmd::GenerateExternalTextureBindings(prg);
         auto result = tint::writer::glsl::Generate(prg, gen_options, entry_point_name);
         if (!result.success) {
             tint::cmd::PrintWGSL(std::cerr, *prg);
@@ -990,55 +1008,6 @@
              m.Add<tint::transform::SubstituteOverride>();
              return true;
          }},
-        {"multiplaner_external_texture",
-         [](tint::inspector::Inspector& inspector, tint::transform::Manager& m,
-            tint::transform::DataMap& i) {
-             using MET = tint::transform::MultiplanarExternalTexture;
-
-             // Generate the MultiplanarExternalTexture::NewBindingPoints by finding two free
-             // binding points. We may wish to expose these binding points via a command line flag
-             // in the future.
-
-             // Set of all the group-0 bindings in use.
-             std::unordered_set<uint32_t> group0_bindings_in_use;
-             auto allocate_binding = [&] {
-                 for (uint32_t idx = 0;; idx++) {
-                     auto binding = tint::transform::BindingPoint{0u, idx};
-                     if (group0_bindings_in_use.emplace(idx).second) {
-                         return binding;
-                     }
-                 }
-             };
-             // Populate group0_bindings_in_use with the existing bindings across all entry points.
-             for (auto ep : inspector.GetEntryPoints()) {
-                 for (auto binding : inspector.GetResourceBindings(ep.name)) {
-                     if (binding.bind_group == 0) {
-                         group0_bindings_in_use.emplace(binding.binding);
-                     }
-                 }
-             }
-             // Allocate new binding points for the external texture's planes and parameters.
-             MET::BindingsMap met_bindings;
-             for (auto ep : inspector.GetEntryPoints()) {
-                 for (auto ext_tex : inspector.GetExternalTextureResourceBindings(ep.name)) {
-                     auto binding = tint::transform::BindingPoint{
-                         ext_tex.bind_group,
-                         ext_tex.binding,
-                     };
-                     if (met_bindings.count(binding)) {
-                         continue;
-                     }
-                     met_bindings.emplace(binding, MET::BindingPoints{
-                                                       /* plane_1 */ allocate_binding(),
-                                                       /* params */ allocate_binding(),
-                                                   });
-                 }
-             }
-
-             i.Add<MET::NewBindingPoints>(std::move(met_bindings));
-             m.Add<MET>();
-             return true;
-         }},
     };
     auto transform_names = [&] {
         tint::utils::StringStream names;
@@ -1055,6 +1024,9 @@
             "  --dump-ir                 -- Writes the IR to stdout\n"
             "  --dump-ir-graph           -- Writes the IR graph to 'tint.dot' as a dot graph\n";
 #endif  // TINT_BUILD_IR
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+        usage += "  --dump-ast                -- Writes the AST to stdout\n";
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
 
         std::cout << usage << std::endl;
         return 0;
@@ -1092,6 +1064,18 @@
         return 1;
     }
 
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+    if (options.dump_syntax_tree) {
+        tint::writer::syntax_tree::Options gen_options;
+        auto result = tint::writer::syntax_tree::Generate(program.get(), gen_options);
+        if (!result.success) {
+            std::cerr << "Failed to dump AST: " << result.error << std::endl;
+        } else {
+            std::cout << result.ast << std::endl;
+        }
+    }
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
+
 #if TINT_BUILD_IR
     if (options.dump_ir || options.dump_ir_graph) {
         auto result = tint::ir::Module::FromProgram(program.get());
diff --git a/src/tint/constant/composite.h b/src/tint/constant/composite.h
index 3bd4973..ef7233c 100644
--- a/src/tint/constant/composite.h
+++ b/src/tint/constant/composite.h
@@ -25,31 +25,37 @@
 namespace tint::constant {
 
 /// Composite holds a number of mixed child values.
-/// Composite may be of a vector, matrix or array type.
+/// Composite may be of a vector, matrix, array or structure type.
 /// If each element is the same type and value, then a Splat would be a more efficient constant
 /// implementation. Use CreateComposite() to create the appropriate type.
-class Composite : public Castable<Composite, constant::Value> {
+class Composite : public Castable<Composite, Value> {
   public:
     /// Constructor
     /// @param t the compsite type
     /// @param els the composite elements
     /// @param all_0 true if all elements are 0
     /// @param any_0 true if any element is 0
-    Composite(const type::Type* t,
-              utils::VectorRef<const constant::Value*> els,
-              bool all_0,
-              bool any_0);
+    Composite(const type::Type* t, utils::VectorRef<const Value*> els, bool all_0, bool any_0);
     ~Composite() override;
 
+    /// @copydoc Value::Type()
     const type::Type* Type() const override { return type; }
 
-    const constant::Value* Index(size_t i) const override {
+    /// @copydoc Value::Index()
+    const Value* Index(size_t i) const override {
         return i < elements.Length() ? elements[i] : nullptr;
     }
 
+    /// @copydoc Value::NumElements()
+    size_t NumElements() const override { return elements.Length(); }
+
+    /// @copydoc Value::AllZero()
     bool AllZero() const override { return all_zero; }
+
+    /// @copydoc Value::AnyZero()
     bool AnyZero() const override { return any_zero; }
-    bool AllEqual() const override { return false; }
+
+    /// @copydoc Value::Hash()
     size_t Hash() const override { return hash; }
 
     /// Clones the constant into the provided context
@@ -60,7 +66,7 @@
     /// The composite type
     type::Type const* const type;
     /// The composite elements
-    const utils::Vector<const constant::Value*, 4> elements;
+    const utils::Vector<const Value*, 4> elements;
     /// True if all elements are zero
     const bool all_zero;
     /// True if any element is zero
@@ -69,6 +75,7 @@
     const size_t hash;
 
   protected:
+    /// @copydoc Value::InternalValue()
     std::variant<std::monostate, AInt, AFloat> InternalValue() const override { return {}; }
 
   private:
diff --git a/src/tint/constant/composite_test.cc b/src/tint/constant/composite_test.cc
index 6fc532d..fd083db 100644
--- a/src/tint/constant/composite_test.cc
+++ b/src/tint/constant/composite_test.cc
@@ -56,20 +56,6 @@
     EXPECT_FALSE(compositeNone->AnyZero());
 }
 
-TEST_F(ConstantTest_Composite, AllEqual) {
-    auto* f32 = create<type::F32>();
-
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
-
-    auto* compositeEq = create<Composite>(f32, utils::Vector{fPos0, fPos0});
-    auto* compositeNe = create<Composite>(f32, utils::Vector{fNeg0, fPos1, fPos0});
-
-    EXPECT_TRUE(compositeEq->AllEqual());
-    EXPECT_FALSE(compositeNe->AllZero());
-}
-
 TEST_F(ConstantTest_Composite, Index) {
     auto* f32 = create<type::F32>();
 
diff --git a/src/tint/constant/scalar.h b/src/tint/constant/scalar.h
index a412d91..fc6aef0 100644
--- a/src/tint/constant/scalar.h
+++ b/src/tint/constant/scalar.h
@@ -25,7 +25,7 @@
 
 /// Scalar holds a single scalar or abstract-numeric value.
 template <typename T>
-class Scalar : public Castable<Scalar<T>, constant::Value> {
+class Scalar : public Castable<Scalar<T>, Value> {
   public:
     static_assert(!std::is_same_v<UnwrapNumber<T>, T> || std::is_same_v<T, bool>,
                   "T must be a Number or bool");
@@ -40,13 +40,22 @@
     }
     ~Scalar() override = default;
 
+    /// @copydoc Value::Type()
     const type::Type* Type() const override { return type; }
 
-    const constant::Value* Index(size_t) const override { return nullptr; }
+    /// @return nullptr, as Scalar does not hold any elements.
+    const Value* Index(size_t) const override { return nullptr; }
 
+    /// @copydoc Value::NumElements()
+    size_t NumElements() const override { return 1; }
+
+    /// @copydoc Value::AllZero()
     bool AllZero() const override { return IsPositiveZero(); }
+
+    /// @copydoc Value::AnyZero()
     bool AnyZero() const override { return IsPositiveZero(); }
-    bool AllEqual() const override { return true; }
+
+    /// @copydoc Value::Hash()
     size_t Hash() const override { return utils::Hash(type, ValueOf()); }
 
     /// Clones the constant into the provided context
@@ -79,6 +88,7 @@
     const T value;
 
   protected:
+    /// @copydoc Value::InternalValue()
     std::variant<std::monostate, AInt, AFloat> InternalValue() const override {
         if constexpr (IsFloatingPoint<UnwrapNumber<T>>) {
             return static_cast<AFloat>(value);
diff --git a/src/tint/constant/scalar_test.cc b/src/tint/constant/scalar_test.cc
index e05cca0..6dedf75 100644
--- a/src/tint/constant/scalar_test.cc
+++ b/src/tint/constant/scalar_test.cc
@@ -155,72 +155,6 @@
     EXPECT_FALSE(aiNeg1->AnyZero());
 }
 
-TEST_F(ConstantTest_Scalar, AllEqual) {
-    auto* i32 = create<type::I32>();
-    auto* u32 = create<type::U32>();
-    auto* f16 = create<type::F16>();
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
-
-    auto* i0 = create<Scalar<tint::i32>>(i32, 0_i);
-    auto* iPos1 = create<Scalar<tint::i32>>(i32, 1_i);
-    auto* iNeg1 = create<Scalar<tint::i32>>(i32, -1_i);
-
-    auto* u0 = create<Scalar<tint::u32>>(u32, 0_u);
-    auto* u1 = create<Scalar<tint::u32>>(u32, 1_u);
-
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
-    auto* fNeg1 = create<Scalar<tint::f32>>(f32, -1_f);
-
-    auto* f16Pos0 = create<Scalar<tint::f16>>(f16, 0_h);
-    auto* f16Neg0 = create<Scalar<tint::f16>>(f16, -0_h);
-    auto* f16Pos1 = create<Scalar<tint::f16>>(f16, 1_h);
-    auto* f16Neg1 = create<Scalar<tint::f16>>(f16, -1_h);
-
-    auto* bf = create<Scalar<bool>>(bool_, false);
-    auto* bt = create<Scalar<bool>>(bool_, true);
-
-    auto* afPos0 = create<Scalar<tint::AFloat>>(f32, 0.0_a);
-    auto* afNeg0 = create<Scalar<tint::AFloat>>(f32, -0.0_a);
-    auto* afPos1 = create<Scalar<tint::AFloat>>(f32, 1.0_a);
-    auto* afNeg1 = create<Scalar<tint::AFloat>>(f32, -1.0_a);
-
-    auto* ai0 = create<Scalar<tint::AInt>>(i32, 0_a);
-    auto* aiPos1 = create<Scalar<tint::AInt>>(i32, 1_a);
-    auto* aiNeg1 = create<Scalar<tint::AInt>>(i32, -1_a);
-
-    EXPECT_TRUE(i0->AllEqual());
-    EXPECT_TRUE(iPos1->AllEqual());
-    EXPECT_TRUE(iNeg1->AllEqual());
-
-    EXPECT_TRUE(u0->AllEqual());
-    EXPECT_TRUE(u1->AllEqual());
-
-    EXPECT_TRUE(fPos0->AllEqual());
-    EXPECT_TRUE(fNeg0->AllEqual());
-    EXPECT_TRUE(fPos1->AllEqual());
-    EXPECT_TRUE(fNeg1->AllEqual());
-
-    EXPECT_TRUE(f16Pos0->AllEqual());
-    EXPECT_TRUE(f16Neg0->AllEqual());
-    EXPECT_TRUE(f16Pos1->AllEqual());
-    EXPECT_TRUE(f16Neg1->AllEqual());
-
-    EXPECT_TRUE(bf->AllEqual());
-    EXPECT_TRUE(bt->AllEqual());
-
-    EXPECT_TRUE(afPos0->AllEqual());
-    EXPECT_TRUE(afNeg0->AllEqual());
-    EXPECT_TRUE(afPos1->AllEqual());
-    EXPECT_TRUE(afNeg1->AllEqual());
-
-    EXPECT_TRUE(ai0->AllEqual());
-    EXPECT_TRUE(aiPos1->AllEqual());
-    EXPECT_TRUE(aiNeg1->AllEqual());
-}
-
 TEST_F(ConstantTest_Scalar, ValueOf) {
     auto* i32 = create<type::I32>();
     auto* u32 = create<type::U32>();
diff --git a/src/tint/constant/splat.h b/src/tint/constant/splat.h
index 5494c8f..a496235 100644
--- a/src/tint/constant/splat.h
+++ b/src/tint/constant/splat.h
@@ -25,14 +25,14 @@
 /// Splat holds a single value, duplicated as all children.
 ///
 /// Splat is used for zero-initializers, 'splat' initializers, or initializers where each element is
-/// identical. Splat may be of a vector, matrix or array type.
-class Splat : public Castable<Splat, constant::Value> {
+/// identical. Splat may be of a vector, matrix, array or structure type.
+class Splat : public Castable<Splat, Value> {
   public:
     /// Constructor
     /// @param t the splat type
     /// @param e the splat element
     /// @param n the number of items in the splat
-    Splat(const type::Type* t, const constant::Value* e, size_t n);
+    Splat(const type::Type* t, const Value* e, size_t n);
     ~Splat() override;
 
     /// @returns the type of the splat
@@ -41,14 +41,15 @@
     /// Retrieve item at index @p i
     /// @param i the index to retrieve
     /// @returns the element, or nullptr if out of bounds
-    const constant::Value* Index(size_t i) const override { return i < count ? el : nullptr; }
+    const Value* Index(size_t i) const override { return i < count ? el : nullptr; }
+
+    /// @copydoc Value::NumElements()
+    size_t NumElements() const override { return count; }
 
     /// @returns true if the element is zero
     bool AllZero() const override { return el->AllZero(); }
     /// @returns true if the element is zero
     bool AnyZero() const override { return el->AnyZero(); }
-    /// @returns true
-    bool AllEqual() const override { return true; }
 
     /// @returns the hash for the splat
     size_t Hash() const override { return utils::Hash(type, el->Hash(), count); }
@@ -61,7 +62,7 @@
     /// The type of the splat element
     type::Type const* const type;
     /// The element stored in the splat
-    const constant::Value* el;
+    const Value* el;
     /// The number of items in the splat
     const size_t count;
 
diff --git a/src/tint/constant/splat_test.cc b/src/tint/constant/splat_test.cc
index 5c897cb..fe8aeda 100644
--- a/src/tint/constant/splat_test.cc
+++ b/src/tint/constant/splat_test.cc
@@ -56,22 +56,6 @@
     EXPECT_FALSE(SpfPos1->AnyZero());
 }
 
-TEST_F(ConstantTest_Splat, AllEqual) {
-    auto* f32 = create<type::F32>();
-
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
-
-    auto* SpfPos0 = create<Splat>(f32, fPos0, 2);
-    auto* SpfNeg0 = create<Splat>(f32, fNeg0, 2);
-    auto* SpfPos1 = create<Splat>(f32, fPos1, 2);
-
-    EXPECT_TRUE(SpfPos0->AllEqual());
-    EXPECT_TRUE(SpfNeg0->AllEqual());
-    EXPECT_TRUE(SpfPos1->AllEqual());
-}
-
 TEST_F(ConstantTest_Splat, Index) {
     auto* f32 = create<type::F32>();
 
diff --git a/src/tint/constant/value.cc b/src/tint/constant/value.cc
index c41ca34..7545731 100644
--- a/src/tint/constant/value.cc
+++ b/src/tint/constant/value.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/constant/value.h"
 
+#include "src/tint/switch.h"
 #include "src/tint/type/array.h"
 #include "src/tint/type/matrix.h"
 #include "src/tint/type/struct.h"
diff --git a/src/tint/constant/value.h b/src/tint/constant/value.h
index d5b9876..eb29998 100644
--- a/src/tint/constant/value.h
+++ b/src/tint/constant/value.h
@@ -37,6 +37,7 @@
     /// @returns the type of the value
     virtual const type::Type* Type() const = 0;
 
+    /// @param i the index of the element
     /// @returns the child element with the given index, or nullptr if there are no children, or
     /// the index is out of bounds.
     ///
@@ -44,7 +45,10 @@
     /// For vectors, this returns the i'th element of the vector.
     /// For matrices, this returns the i'th column vector of the matrix.
     /// For structures, this returns the i'th member field of the structure.
-    virtual const Value* Index(size_t) const = 0;
+    virtual const Value* Index(size_t i) const = 0;
+
+    /// @return the number of elements held by this Value
+    virtual size_t NumElements() const = 0;
 
     /// @returns true if child elements are positive-zero valued.
     virtual bool AllZero() const = 0;
@@ -52,9 +56,6 @@
     /// @returns true if any child elements are positive-zero valued.
     virtual bool AnyZero() const = 0;
 
-    /// @returns true if all child elements have the same value and type.
-    virtual bool AllEqual() const = 0;
-
     /// @returns a hash of the value.
     virtual size_t Hash() const = 0;
 
@@ -74,7 +75,7 @@
 
     /// @param b the value to compare too
     /// @returns true if this value is equal to @p b
-    bool Equal(const constant::Value* b) const;
+    bool Equal(const Value* b) const;
 
     /// Clones the constant into the provided context
     /// @param ctx the clone context
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index 6e96523..93e5c58 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -39,6 +39,7 @@
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/struct.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/array.h"
 #include "src/tint/type/bool.h"
 #include "src/tint/type/depth_multisampled_texture.h"
@@ -570,8 +571,10 @@
     // Ast nodes for enable directive are stored within global declarations list
     auto global_decls = program_->AST().GlobalDeclarations();
     for (auto* node : global_decls) {
-        if (auto* ext = node->As<ast::Enable>()) {
-            result.push_back({utils::ToString(ext->extension), ext->source});
+        if (auto* enable = node->As<ast::Enable>()) {
+            for (auto* ext : enable->extensions) {
+                result.push_back({utils::ToString(ext->name), ext->source});
+            }
         }
     }
 
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index 316d224..fae4ee4 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -739,7 +739,9 @@
 @must_use fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32>
 @must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
 @must_use fn textureNumLayers<T: fiu32>(texture: texture_2d_array<T>) -> u32
+@must_use fn textureNumLayers<T: fiu32>(texture: texture_cube_array<T>) -> u32
 @must_use fn textureNumLayers(texture: texture_depth_2d_array) -> u32
+@must_use fn textureNumLayers(texture: texture_depth_cube_array) -> u32
 @must_use fn textureNumLayers<F: texel_format, A: write>(texture: texture_storage_2d_array<F, A>) -> u32
 @must_use fn textureNumLevels<T: fiu32>(texture: texture_1d<T>) -> u32
 @must_use fn textureNumLevels<T: fiu32>(texture: texture_2d<T>) -> u32
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 1452dc4..a3d2a31 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -177,4 +177,26 @@
     return ir.instructions.Create<ir::Bitcast>(Temp(type), val);
 }
 
+ir::UserCall* Builder::UserCall(const type::Type* type,
+                                Symbol name,
+                                utils::VectorRef<Value*> args) {
+    return ir.instructions.Create<ir::UserCall>(Temp(type), name, std::move(args));
+}
+
+ir::Convert* Builder::Convert(const type::Type* to,
+                              const type::Type* from,
+                              utils::VectorRef<Value*> args) {
+    return ir.instructions.Create<ir::Convert>(Temp(to), from, std::move(args));
+}
+
+ir::Construct* Builder::Construct(const type::Type* to, utils::VectorRef<Value*> args) {
+    return ir.instructions.Create<ir::Construct>(Temp(to), std::move(args));
+}
+
+ir::Builtin* Builder::Builtin(const type::Type* type,
+                              builtin::Function func,
+                              utils::VectorRef<Value*> args) {
+    return ir.instructions.Create<ir::Builtin>(Temp(type), func, args);
+}
+
 }  // namespace tint::ir
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 147e4c4..5a39dbb 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -20,7 +20,10 @@
 #include "src/tint/constant/scalar.h"
 #include "src/tint/ir/binary.h"
 #include "src/tint/ir/bitcast.h"
+#include "src/tint/ir/builtin.h"
 #include "src/tint/ir/constant.h"
+#include "src/tint/ir/construct.h"
+#include "src/tint/ir/convert.h"
 #include "src/tint/ir/function.h"
 #include "src/tint/ir/if.h"
 #include "src/tint/ir/loop.h"
@@ -28,6 +31,7 @@
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/temp.h"
 #include "src/tint/ir/terminator.h"
+#include "src/tint/ir/user_call.h"
 #include "src/tint/ir/value.h"
 #include "src/tint/type/bool.h"
 #include "src/tint/type/f16.h"
@@ -279,6 +283,37 @@
     /// @returns the instruction
     ir::Bitcast* Bitcast(const type::Type* type, Value* val);
 
+    /// Creates a user function call instruction
+    /// @param type the return type of the call
+    /// @param name the name of the function being called
+    /// @param args the call arguments
+    /// @returns the instruction
+    ir::UserCall* UserCall(const type::Type* type, Symbol name, utils::VectorRef<Value*> args);
+
+    /// Creates a value conversion instruction
+    /// @param to the type converted to
+    /// @param from the type converted from
+    /// @param args the arguments to be converted
+    /// @returns the instruction
+    ir::Convert* Convert(const type::Type* to,
+                         const type::Type* from,
+                         utils::VectorRef<Value*> args);
+
+    /// Creates a value constructor instruction
+    /// @param to the type being converted
+    /// @param args the arguments to be converted
+    /// @returns the instruction
+    ir::Construct* Construct(const type::Type* to, utils::VectorRef<Value*> args);
+
+    /// Creates a builtin call instruction
+    /// @param type the return type
+    /// @param func the builtin function
+    /// @param args the arguments to be converted
+    /// @returns the instruction
+    ir::Builtin* Builtin(const type::Type* type,
+                         builtin::Function func,
+                         utils::VectorRef<Value*> args);
+
     /// @returns a unique temp id
     Temp::Id AllocateTempId();
 
diff --git a/src/tint/ir/builder_impl.cc b/src/tint/ir/builder_impl.cc
index d3f8d53..ba63be6 100644
--- a/src/tint/ir/builder_impl.cc
+++ b/src/tint/ir/builder_impl.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/ir/builder_impl.h"
 
+#include <iostream>
+
 #include "src/tint/ast/alias.h"
 #include "src/tint/ast/binary_expression.h"
 #include "src/tint/ast/bitcast_expression.h"
@@ -21,6 +23,8 @@
 #include "src/tint/ast/bool_literal_expression.h"
 #include "src/tint/ast/break_if_statement.h"
 #include "src/tint/ast/break_statement.h"
+#include "src/tint/ast/call_expression.h"
+#include "src/tint/ast/call_statement.h"
 #include "src/tint/ast/const_assert.h"
 #include "src/tint/ast/continue_statement.h"
 #include "src/tint/ast/float_literal_expression.h"
@@ -28,6 +32,7 @@
 #include "src/tint/ast/function.h"
 #include "src/tint/ast/id_attribute.h"
 #include "src/tint/ast/identifier.h"
+#include "src/tint/ast/identifier_expression.h"
 #include "src/tint/ast/if_statement.h"
 #include "src/tint/ast/int_literal_expression.h"
 #include "src/tint/ast/literal_expression.h"
@@ -39,6 +44,7 @@
 #include "src/tint/ast/struct_member_align_attribute.h"
 #include "src/tint/ast/struct_member_size_attribute.h"
 #include "src/tint/ast/switch_statement.h"
+#include "src/tint/ast/templated_identifier.h"
 #include "src/tint/ast/variable_decl_statement.h"
 #include "src/tint/ast/while_statement.h"
 #include "src/tint/ir/function.h"
@@ -48,9 +54,15 @@
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/terminator.h"
 #include "src/tint/program.h"
+#include "src/tint/sem/builtin.h"
+#include "src/tint/sem/call.h"
+#include "src/tint/sem/materialize.h"
 #include "src/tint/sem/module.h"
 #include "src/tint/sem/switch_statement.h"
+#include "src/tint/sem/value_constructor.h"
+#include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/void.h"
 
 namespace tint::ir {
@@ -99,6 +111,10 @@
 
 BuilderImpl::~BuilderImpl() = default;
 
+void BuilderImpl::add_error(const Source& s, const std::string& err) {
+    diagnostics_.add_error(tint::diag::System::IR, err, s);
+}
+
 void BuilderImpl::BranchTo(FlowNode* node, utils::VectorRef<Value*> args) {
     TINT_ASSERT(IR, current_flow_block);
     TINT_ASSERT(IR, !IsBranched(current_flow_block));
@@ -161,9 +177,7 @@
                 return true;
             },
             [&](Default) {
-                diagnostics_.add_warning(tint::diag::System::IR,
-                                         "unknown type: " + std::string(decl->TypeInfo().name),
-                                         decl->source);
+                add_error(decl->source, "unknown type: " + std::string(decl->TypeInfo().name));
                 return true;
             });
         if (!ok) {
@@ -237,9 +251,7 @@
         [&](const ast::BlockStatement* b) { return EmitBlock(b); },
         [&](const ast::BreakStatement* b) { return EmitBreak(b); },
         [&](const ast::BreakIfStatement* b) { return EmitBreakIf(b); },
-        // [&](const ast::CallStatement* c) {
-        // TODO(dsinclair): Implement
-        // },
+        [&](const ast::CallStatement* c) { return EmitCall(c); },
         // [&](const ast::CompoundAssignmentStatement* c) {
         // TODO(dsinclair): Implement
         // },
@@ -258,9 +270,8 @@
             return true;  // Not emitted
         },
         [&](Default) {
-            diagnostics_.add_warning(
-                tint::diag::System::IR,
-                "unknown statement type: " + std::string(stmt->TypeInfo().name), stmt->source);
+            add_error(stmt->source,
+                      "unknown statement type: " + std::string(stmt->TypeInfo().name));
             // TODO(dsinclair): This should return `false`, switch back when all
             // the cases are handled.
             return true;
@@ -593,9 +604,7 @@
         // },
         [&](const ast::BinaryExpression* b) { return EmitBinary(b); },
         [&](const ast::BitcastExpression* b) { return EmitBitcast(b); },
-        // [&](const ast::CallExpression* c) {
-        // TODO(dsinclair): Implement
-        // },
+        [&](const ast::CallExpression* c) { return EmitCall(c); },
         // [&](const ast::IdentifierExpression* i) {
         // TODO(dsinclair): Implement
         // },
@@ -610,9 +619,8 @@
         // TODO(dsinclair): Implement
         // },
         [&](Default) {
-            diagnostics_.add_warning(
-                tint::diag::System::IR,
-                "unknown expression type: " + std::string(expr->TypeInfo().name), expr->source);
+            add_error(expr->source,
+                      "unknown expression type: " + std::string(expr->TypeInfo().name));
             // TODO(dsinclair): This should return utils::Failure; Switch back
             // once all the above cases are handled.
             auto* v = builder.ir.types.Get<type::Void>();
@@ -630,19 +638,16 @@
         // TODO(dsinclair): Implement
         // },
         [&](const ast::Override*) {
-            diagnostics_.add_warning(tint::diag::System::IR,
-                                     "found an `Override` variable. The SubstituteOverrides "
-                                     "transform must be run before converting to IR",
-                                     var->source);
+            add_error(var->source,
+                      "found an `Override` variable. The SubstituteOverrides "
+                      "transform must be run before converting to IR");
             return false;
         },
         // [&](const ast::Const* c) {
         // TODO(dsinclair): Implement
         // },
         [&](Default) {
-            diagnostics_.add_warning(tint::diag::System::IR,
-                                     "unknown variable: " + std::string(var->TypeInfo().name),
-                                     var->source);
+            add_error(var->source, "unknown variable: " + std::string(var->TypeInfo().name));
 
             // TODO(dsinclair): This should return `false`, switch back when all
             // the cases are handled.
@@ -743,22 +748,83 @@
     return instr->Result();
 }
 
+utils::Result<Value*> BuilderImpl::EmitCall(const ast::CallStatement* stmt) {
+    return EmitCall(stmt->expr);
+}
+
+utils::Result<Value*> BuilderImpl::EmitCall(const ast::CallExpression* expr) {
+    // If this is a materialized semantic node, just use the constant value.
+    if (auto* mat = program_->Sem().Get(expr)) {
+        if (mat->ConstantValue()) {
+            auto* cv = mat->ConstantValue()->Clone(clone_ctx_);
+            if (!cv) {
+                add_error(expr->source, "failed to get constant value for call " +
+                                            std::string(expr->TypeInfo().name));
+                return utils::Failure;
+            }
+            return builder.Constant(cv);
+        }
+    }
+
+    utils::Vector<Value*, 8> args;
+    args.Reserve(expr->args.Length());
+
+    // Emit the arguments
+    for (const auto* arg : expr->args) {
+        auto value = EmitExpression(arg);
+        if (!value) {
+            add_error(arg->source, "failed to convert arguments");
+            return utils::Failure;
+        }
+        args.Push(value.Get());
+    }
+
+    auto* sem = program_->Sem().Get<sem::Call>(expr);
+    if (!sem) {
+        add_error(expr->source, "failed to get semantic information for call " +
+                                    std::string(expr->TypeInfo().name));
+        return utils::Failure;
+    }
+
+    auto* ty = sem->Target()->ReturnType()->Clone(clone_ctx_.type_ctx);
+
+    Instruction* instr = nullptr;
+
+    // If this is a builtin function, emit the specific builtin value
+    if (auto* b = sem->Target()->As<sem::Builtin>()) {
+        instr = builder.Builtin(ty, b->Type(), args);
+    } else if (sem->Target()->As<sem::ValueConstructor>()) {
+        instr = builder.Construct(ty, std::move(args));
+    } else if (auto* conv = sem->Target()->As<sem::ValueConversion>()) {
+        auto* from = conv->Source()->Clone(clone_ctx_.type_ctx);
+        instr = builder.Convert(ty, from, std::move(args));
+    } else if (expr->target->identifier->Is<ast::TemplatedIdentifier>()) {
+        TINT_UNIMPLEMENTED(IR, diagnostics_) << "missing templated ident support";
+        return utils::Failure;
+    } else {
+        // Not a builtin and not a templated call, so this is a user function.
+        auto name = CloneSymbol(expr->target->identifier->symbol);
+        instr = builder.UserCall(ty, name, std::move(args));
+    }
+    if (instr == nullptr) {
+        return utils::Failure;
+    }
+    current_flow_block->instructions.Push(instr);
+    return instr->Result();
+}
+
 utils::Result<Value*> BuilderImpl::EmitLiteral(const ast::LiteralExpression* lit) {
     auto* sem = program_->Sem().Get(lit);
     if (!sem) {
-        diagnostics_.add_error(
-            tint::diag::System::IR,
-            "Failed to get semantic information for node " + std::string(lit->TypeInfo().name),
-            lit->source);
+        add_error(lit->source, "failed to get semantic information for node " +
+                                   std::string(lit->TypeInfo().name));
         return utils::Failure;
     }
 
     auto* cv = sem->ConstantValue()->Clone(clone_ctx_);
     if (!cv) {
-        diagnostics_.add_error(
-            tint::diag::System::IR,
-            "Failed to get constant value for node " + std::string(lit->TypeInfo().name),
-            lit->source);
+        add_error(lit->source,
+                  "failed to get constant value for node " + std::string(lit->TypeInfo().name));
         return utils::Failure;
     }
     return builder.Constant(cv);
@@ -804,10 +870,9 @@
         // TODO(dsinclair): Implement
         // },
         [&](const ast::IdAttribute*) {
-            diagnostics_.add_warning(tint::diag::System::IR,
-                                     "found an `Id` attribute. The SubstituteOverrides transform "
-                                     "must be run before converting to IR",
-                                     attr->source);
+            add_error(attr->source,
+                      "found an `Id` attribute. The SubstituteOverrides transform "
+                      "must be run before converting to IR");
             return false;
         },
         [&](const ast::StructMemberSizeAttribute*) {
@@ -827,9 +892,7 @@
         // TODO(dsinclair): Implement
         // },
         [&](Default) {
-            diagnostics_.add_warning(tint::diag::System::IR,
-                                     "unknown attribute: " + std::string(attr->TypeInfo().name),
-                                     attr->source);
+            add_error(attr->source, "unknown attribute: " + std::string(attr->TypeInfo().name));
             return false;
         });
 }
diff --git a/src/tint/ir/builder_impl.h b/src/tint/ir/builder_impl.h
index 034ab65..2e38ef7 100644
--- a/src/tint/ir/builder_impl.h
+++ b/src/tint/ir/builder_impl.h
@@ -39,6 +39,8 @@
 class BlockStatement;
 class BreakIfStatement;
 class BreakStatement;
+class CallExpression;
+class CallStatement;
 class ContinueStatement;
 class Expression;
 class ForLoopStatement;
@@ -61,6 +63,9 @@
 class Switch;
 class Terminator;
 }  // namespace tint::ir
+namespace tint::sem {
+class Builtin;
+}  // namespace tint::sem
 
 namespace tint::ir {
 
@@ -165,6 +170,16 @@
     /// @returns the value storing the result if successful, utils::Failure otherwise
     utils::Result<Value*> EmitBitcast(const ast::BitcastExpression* expr);
 
+    /// Emits a call expression
+    /// @param stmt the call statement
+    /// @returns the value storing the result if successful, utils::Failure otherwise
+    utils::Result<Value*> EmitCall(const ast::CallStatement* stmt);
+
+    /// Emits a call expression
+    /// @param expr the call expression
+    /// @returns the value storing the result if successful, utils::Failure otherwise
+    utils::Result<Value*> EmitCall(const ast::CallExpression* expr);
+
     /// Emits a literal expression
     /// @param lit the literal to emit
     /// @returns true if successful, false otherwise
@@ -207,6 +222,8 @@
 
     FlowNode* FindEnclosingControl(ControlFlags flags);
 
+    void add_error(const Source& s, const std::string& err);
+
     const Program* program_ = nullptr;
 
     Symbol CloneSymbol(Symbol sym) const;
diff --git a/src/tint/ir/builder_impl_test.cc b/src/tint/ir/builder_impl_test.cc
index 9af481b..4e02875 100644
--- a/src/tint/ir/builder_impl_test.cc
+++ b/src/tint/ir/builder_impl_test.cc
@@ -1858,5 +1858,106 @@
 )");
 }
 
+TEST_F(IR_BuilderImplTest, EmitStatement_UserFunction) {
+    Func("my_func", utils::Vector{Param("p", ty.f32())}, ty.void_(), utils::Empty);
+
+    auto* stmt = CallStmt(Call("my_func", Mul(2_f, 3_f)));
+    WrapInFunction(stmt);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitStatement(stmt);
+    ASSERT_TRUE(r) << b.error();
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%1 (f32) = 2.0 * 3.0
+%2 (void) = call(my_func, %1 (f32))
+)");
+}
+
+// TODO(dsinclair): This needs assignment in order to output correctly. The empty constructor ends
+// up materializing, so there is no expression to emit until there is a usage. When assigment is
+// implemented this can be enabled (and the output updated).
+TEST_F(IR_BuilderImplTest, DISABLED_EmitExpression_ConstructEmpty) {
+    auto* expr = vec3(ty.f32());
+    GlobalVar("i", builtin::AddressSpace::kPrivate, expr);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitExpression(expr);
+    ASSERT_TRUE(r) << b.error();
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%1 (vec3<f32>) = construct(vec3<f32>)
+)");
+}
+
+TEST_F(IR_BuilderImplTest, EmitExpression_Construct) {
+    auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_f));
+    auto* expr = vec3(ty.f32(), 2_f, 3_f, i);
+    WrapInFunction(expr);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitExpression(expr);
+    ASSERT_TRUE(r) << b.error();
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%2 (vec3<f32>) = construct(vec3<f32>, 2.0, 3.0, %1 (void))
+)");
+}
+
+TEST_F(IR_BuilderImplTest, EmitExpression_Convert) {
+    auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_i));
+    auto* expr = Call(ty.f32(), i);
+    WrapInFunction(expr);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitExpression(expr);
+    ASSERT_TRUE(r) << b.error();
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%2 (f32) = convert(f32, i32, %1 (void))
+)");
+}
+
+TEST_F(IR_BuilderImplTest, EmitExpression_MaterializedCall) {
+    auto* expr = Return(Call("trunc", 2.5_f));
+
+    Func("test_function", {}, ty.f32(), expr, utils::Empty);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
+  %bb1 = Block
+  Return (2.0)
+FunctionEnd
+
+)");
+}
+
+TEST_F(IR_BuilderImplTest, EmitExpression_Builtin) {
+    auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_f));
+    auto* expr = Call("asin", i);
+    WrapInFunction(expr);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitExpression(expr);
+    ASSERT_TRUE(r) << b.error();
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%2 (f32) = asin(%1 (void))
+)");
+}
+
 }  // namespace
 }  // namespace tint::ir
diff --git a/src/tint/ir/builtin.cc b/src/tint/ir/builtin.cc
new file mode 100644
index 0000000..e9acf66
--- /dev/null
+++ b/src/tint/ir/builtin.cc
@@ -0,0 +1,37 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/builtin.h"
+#include "src/tint/debug.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::Builtin);
+
+// \cond DO_NOT_DOCUMENT
+namespace tint::ir {
+
+Builtin::Builtin(Value* result, builtin::Function func, utils::VectorRef<Value*> args)
+    : Base(result, args), func_(func) {}
+
+Builtin::~Builtin() = default;
+
+utils::StringStream& Builtin::ToString(utils::StringStream& out, const SymbolTable& st) const {
+    Result()->ToString(out, st);
+    out << " = " << builtin::str(func_) << "(";
+    EmitArgs(out, st);
+    out << ")";
+    return out;
+}
+
+}  // namespace tint::ir
+// \endcond
diff --git a/src/tint/ir/builtin.h b/src/tint/ir/builtin.h
new file mode 100644
index 0000000..0385c6c
--- /dev/null
+++ b/src/tint/ir/builtin.h
@@ -0,0 +1,57 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_BUILTIN_H_
+#define SRC_TINT_IR_BUILTIN_H_
+
+#include "src/tint/builtin/function.h"
+#include "src/tint/castable.h"
+#include "src/tint/ir/call.h"
+#include "src/tint/symbol_table.h"
+#include "src/tint/type/type.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// A value conversion instruction in the IR.
+class Builtin : public Castable<Builtin, Call> {
+  public:
+    /// Constructor
+    /// @param result the result value
+    /// @param func the builtin function
+    /// @param args the conversion arguments
+    Builtin(Value* result, builtin::Function func, utils::VectorRef<Value*> args);
+    Builtin(const Builtin& instr) = delete;
+    Builtin(Builtin&& instr) = delete;
+    ~Builtin() override;
+
+    Builtin& operator=(const Builtin& instr) = delete;
+    Builtin& operator=(Builtin&& instr) = delete;
+
+    /// @returns the builtin function
+    builtin::Function Func() const { return func_; }
+
+    /// Write the instruction to the given stream
+    /// @param out the stream to write to
+    /// @param st the symbol table
+    /// @returns the stream
+    utils::StringStream& ToString(utils::StringStream& out, const SymbolTable& st) const override;
+
+  private:
+    const builtin::Function func_;
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_BUILTIN_H_
diff --git a/src/tint/ir/call.cc b/src/tint/ir/call.cc
new file mode 100644
index 0000000..9dda1f9
--- /dev/null
+++ b/src/tint/ir/call.cc
@@ -0,0 +1,40 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/call.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::Call);
+
+namespace tint::ir {
+
+Call::Call(Value* result, utils::VectorRef<Value*> args) : Base(result), args_(args) {
+    for (auto* arg : args) {
+        arg->AddUsage(this);
+    }
+}
+
+Call::~Call() = default;
+
+void Call::EmitArgs(utils::StringStream& out, const SymbolTable& st) const {
+    bool first = true;
+    for (const auto* arg : args_) {
+        if (!first) {
+            out << ", ";
+        }
+        first = false;
+        arg->ToString(out, st);
+    }
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/call.h b/src/tint/ir/call.h
new file mode 100644
index 0000000..d6ced3f
--- /dev/null
+++ b/src/tint/ir/call.h
@@ -0,0 +1,54 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_CALL_H_
+#define SRC_TINT_IR_CALL_H_
+
+#include "src/tint/castable.h"
+#include "src/tint/ir/instruction.h"
+#include "src/tint/symbol_table.h"
+#include "src/tint/type/type.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// A Call instruction in the IR.
+class Call : public Castable<Call, Instruction> {
+  public:
+    /// Constructor
+    /// @param result the result value
+    /// @param args the constructor arguments
+    Call(Value* result, utils::VectorRef<Value*> args);
+    Call(const Call& instr) = delete;
+    Call(Call&& instr) = delete;
+    ~Call() override;
+
+    Call& operator=(const Call& instr) = delete;
+    Call& operator=(Call&& instr) = delete;
+
+    /// @returns the constructor arguments
+    utils::VectorRef<Value*> Args() const { return args_; }
+
+    /// Writes the call arguments to the given stream.
+    /// @param out the output stream
+    /// @param st the symbol table
+    void EmitArgs(utils::StringStream& out, const SymbolTable& st) const;
+
+  private:
+    utils::Vector<Value*, 1> args_;
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_CALL_H_
diff --git a/src/tint/ir/constant.cc b/src/tint/ir/constant.cc
index da4cb36..61610b0 100644
--- a/src/tint/ir/constant.cc
+++ b/src/tint/ir/constant.cc
@@ -19,6 +19,7 @@
 #include "src/tint/constant/composite.h"
 #include "src/tint/constant/scalar.h"
 #include "src/tint/constant/splat.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Constant);
 
diff --git a/src/tint/ir/construct.cc b/src/tint/ir/construct.cc
new file mode 100644
index 0000000..27bb084
--- /dev/null
+++ b/src/tint/ir/construct.cc
@@ -0,0 +1,37 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/construct.h"
+#include "src/tint/debug.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::Construct);
+
+namespace tint::ir {
+
+Construct::Construct(Value* result, utils::VectorRef<Value*> args) : Base(result, args) {}
+
+Construct::~Construct() = default;
+
+utils::StringStream& Construct::ToString(utils::StringStream& out, const SymbolTable& st) const {
+    Result()->ToString(out, st);
+    out << " = construct(" << Result()->Type()->FriendlyName(st);
+    if (!Args().IsEmpty()) {
+        out << ", ";
+        EmitArgs(out, st);
+    }
+    out << ")";
+    return out;
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/construct.h b/src/tint/ir/construct.h
new file mode 100644
index 0000000..6f620d3
--- /dev/null
+++ b/src/tint/ir/construct.h
@@ -0,0 +1,49 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_CONSTRUCT_H_
+#define SRC_TINT_IR_CONSTRUCT_H_
+
+#include "src/tint/castable.h"
+#include "src/tint/ir/call.h"
+#include "src/tint/symbol_table.h"
+#include "src/tint/type/type.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// A constructor instruction in the IR.
+class Construct : public Castable<Construct, Call> {
+  public:
+    /// Constructor
+    /// @param result the result value
+    /// @param args the constructor arguments
+    Construct(Value* result, utils::VectorRef<Value*> args);
+    Construct(const Construct& instr) = delete;
+    Construct(Construct&& instr) = delete;
+    ~Construct() override;
+
+    Construct& operator=(const Construct& instr) = delete;
+    Construct& operator=(Construct&& instr) = delete;
+
+    /// Write the instruction to the given stream
+    /// @param out the stream to write to
+    /// @param st the symbol table
+    /// @returns the stream
+    utils::StringStream& ToString(utils::StringStream& out, const SymbolTable& st) const override;
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_CONSTRUCT_H_
diff --git a/src/tint/ir/convert.cc b/src/tint/ir/convert.cc
new file mode 100644
index 0000000..e845adb
--- /dev/null
+++ b/src/tint/ir/convert.cc
@@ -0,0 +1,36 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/convert.h"
+#include "src/tint/debug.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::Convert);
+
+namespace tint::ir {
+
+Convert::Convert(Value* result, const type::Type* from, utils::VectorRef<Value*> args)
+    : Base(result, args), from_(from) {}
+
+Convert::~Convert() = default;
+
+utils::StringStream& Convert::ToString(utils::StringStream& out, const SymbolTable& st) const {
+    Result()->ToString(out, st);
+    out << " = convert(" << Result()->Type()->FriendlyName(st) << ", " << from_->FriendlyName(st)
+        << ", ";
+    EmitArgs(out, st);
+    out << ")";
+    return out;
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/convert.h b/src/tint/ir/convert.h
new file mode 100644
index 0000000..5132248
--- /dev/null
+++ b/src/tint/ir/convert.h
@@ -0,0 +1,58 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_CONVERT_H_
+#define SRC_TINT_IR_CONVERT_H_
+
+#include "src/tint/castable.h"
+#include "src/tint/ir/call.h"
+#include "src/tint/symbol_table.h"
+#include "src/tint/type/type.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// A value conversion instruction in the IR.
+class Convert : public Castable<Convert, Call> {
+  public:
+    /// Constructor
+    /// @param result the result value
+    /// @param from the type being converted from
+    /// @param args the conversion arguments
+    Convert(Value* result, const type::Type* from, utils::VectorRef<Value*> args);
+    Convert(const Convert& instr) = delete;
+    Convert(Convert&& instr) = delete;
+    ~Convert() override;
+
+    Convert& operator=(const Convert& instr) = delete;
+    Convert& operator=(Convert&& instr) = delete;
+
+    /// @returns the from type
+    const type::Type* From() const { return from_; }
+    /// @returns the to type
+    const type::Type* To() const { return Result()->Type(); }
+
+    /// Write the instruction to the given stream
+    /// @param out the stream to write to
+    /// @param st the symbol table
+    /// @returns the stream
+    utils::StringStream& ToString(utils::StringStream& out, const SymbolTable& st) const override;
+
+  private:
+    const type::Type* from_ = nullptr;
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_CONVERT_H_
diff --git a/src/tint/ir/debug.cc b/src/tint/ir/debug.cc
index 290aaeb8..eb7d40f 100644
--- a/src/tint/ir/debug.cc
+++ b/src/tint/ir/debug.cc
@@ -22,6 +22,7 @@
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/terminator.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::ir {
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index 1bac411..041495d 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -19,6 +19,7 @@
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/terminator.h"
+#include "src/tint/switch.h"
 
 namespace tint::ir {
 namespace {
diff --git a/src/tint/ir/test_helper.h b/src/tint/ir/test_helper.h
index 9fb54cc..6e36ed3 100644
--- a/src/tint/ir/test_helper.h
+++ b/src/tint/ir/test_helper.h
@@ -40,6 +40,8 @@
     /// return the same builder without rebuilding.
     /// @return the builder
     BuilderImpl& CreateBuilder() {
+        SetResolveOnBuild(true);
+
         if (gen_) {
             return *gen_;
         }
diff --git a/src/tint/ir/user_call.cc b/src/tint/ir/user_call.cc
new file mode 100644
index 0000000..cf672cf
--- /dev/null
+++ b/src/tint/ir/user_call.cc
@@ -0,0 +1,36 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/user_call.h"
+#include "src/tint/debug.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::UserCall);
+
+namespace tint::ir {
+
+UserCall::UserCall(Value* result, Symbol name, utils::VectorRef<Value*> args)
+    : Base(result, args), name_(name) {}
+
+UserCall::~UserCall() = default;
+
+utils::StringStream& UserCall::ToString(utils::StringStream& out, const SymbolTable& st) const {
+    Result()->ToString(out, st);
+    out << " = call(";
+    out << st.NameFor(name_) << ", ";
+    EmitArgs(out, st);
+    out << ")";
+    return out;
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/user_call.h b/src/tint/ir/user_call.h
new file mode 100644
index 0000000..2edeecb
--- /dev/null
+++ b/src/tint/ir/user_call.h
@@ -0,0 +1,56 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_USER_CALL_H_
+#define SRC_TINT_IR_USER_CALL_H_
+
+#include "src/tint/castable.h"
+#include "src/tint/ir/call.h"
+#include "src/tint/symbol_table.h"
+#include "src/tint/type/type.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// A user call instruction in the IR.
+class UserCall : public Castable<UserCall, Call> {
+  public:
+    /// Constructor
+    /// @param result the result value
+    /// @param name the function name
+    /// @param args the function arguments
+    UserCall(Value* result, Symbol name, utils::VectorRef<Value*> args);
+    UserCall(const UserCall& instr) = delete;
+    UserCall(UserCall&& instr) = delete;
+    ~UserCall() override;
+
+    UserCall& operator=(const UserCall& instr) = delete;
+    UserCall& operator=(UserCall&& instr) = delete;
+
+    /// @returns the function name
+    Symbol Name() const { return name_; }
+
+    /// Write the instruction to the given stream
+    /// @param out the stream to write to
+    /// @param st the symbol table
+    /// @returns the stream
+    utils::StringStream& ToString(utils::StringStream& out, const SymbolTable& st) const override;
+
+  private:
+    Symbol name_{};
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_USER_CALL_H_
diff --git a/src/tint/program.cc b/src/tint/program.cc
index 432758b..643999d 100644
--- a/src/tint/program.cc
+++ b/src/tint/program.cc
@@ -19,6 +19,7 @@
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/sem/type_expression.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 
 namespace tint {
 namespace {
diff --git a/src/tint/program_builder.cc b/src/tint/program_builder.cc
index c0c2ef6..99fce9e 100644
--- a/src/tint/program_builder.cc
+++ b/src/tint/program_builder.cc
@@ -21,6 +21,7 @@
 #include "src/tint/sem/type_expression.h"
 #include "src/tint/sem/value_expression.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/compiler_macros.h"
 
 using namespace tint::number_suffixes;  // NOLINT
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index c84a6e0..31f566b 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -2048,20 +2048,22 @@
     }
 
     /// Adds the extension to the list of enable directives at the top of the module.
-    /// @param ext the extension to enable
+    /// @param extension the extension to enable
     /// @return an `ast::Enable` enabling the given extension.
-    const ast::Enable* Enable(builtin::Extension ext) {
-        auto* enable = create<ast::Enable>(ext);
+    const ast::Enable* Enable(builtin::Extension extension) {
+        auto* ext = create<ast::Extension>(extension);
+        auto* enable = create<ast::Enable>(utils::Vector{ext});
         AST().AddEnable(enable);
         return enable;
     }
 
     /// Adds the extension to the list of enable directives at the top of the module.
     /// @param source the enable source
-    /// @param ext the extension to enable
+    /// @param extension the extension to enable
     /// @return an `ast::Enable` enabling the given extension.
-    const ast::Enable* Enable(const Source& source, builtin::Extension ext) {
-        auto* enable = create<ast::Enable>(source, ext);
+    const ast::Enable* Enable(const Source& source, builtin::Extension extension) {
+        auto* ext = create<ast::Extension>(source, extension);
+        auto* enable = create<ast::Enable>(source, utils::Vector{ext});
         AST().AddEnable(enable);
         return enable;
     }
@@ -3130,14 +3132,16 @@
     /// @param condition the if statement condition expression
     /// @param body the if statement body
     /// @param else_stmt optional else statement
+    /// @param attributes optional attributes
     /// @returns the if statement pointer
     template <typename CONDITION>
     const ast::IfStatement* If(const Source& source,
                                CONDITION&& condition,
                                const ast::BlockStatement* body,
-                               const ElseStmt else_stmt = ElseStmt()) {
+                               const ElseStmt else_stmt = ElseStmt(),
+                               utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
         return create<ast::IfStatement>(source, Expr(std::forward<CONDITION>(condition)), body,
-                                        else_stmt.stmt);
+                                        else_stmt.stmt, std::move(attributes));
     }
 
     /// Creates a ast::IfStatement with input condition, body, and optional
@@ -3145,13 +3149,15 @@
     /// @param condition the if statement condition expression
     /// @param body the if statement body
     /// @param else_stmt optional else statement
+    /// @param attributes optional attributes
     /// @returns the if statement pointer
     template <typename CONDITION>
     const ast::IfStatement* If(CONDITION&& condition,
                                const ast::BlockStatement* body,
-                               const ElseStmt else_stmt = ElseStmt()) {
+                               const ElseStmt else_stmt = ElseStmt(),
+                               utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
         return create<ast::IfStatement>(Expr(std::forward<CONDITION>(condition)), body,
-                                        else_stmt.stmt);
+                                        else_stmt.stmt, std::move(attributes));
     }
 
     /// Creates an Else object.
@@ -3274,58 +3280,74 @@
         return create<ast::LoopStatement>(body, continuing);
     }
 
-    /// Creates a ast::ForLoopStatement with input body and optional initializer,
-    /// condition and continuing.
+    /// Creates a ast::ForLoopStatement with input body and optional initializer, condition,
+    /// continuing, and attributes.
     /// @param source the source information
     /// @param init the optional loop initializer
     /// @param cond the optional loop condition
     /// @param cont the optional loop continuing
     /// @param body the loop body
+    /// @param attributes optional attributes
     /// @returns the for loop statement pointer
     template <typename COND>
-    const ast::ForLoopStatement* For(const Source& source,
-                                     const ast::Statement* init,
-                                     COND&& cond,
-                                     const ast::Statement* cont,
-                                     const ast::BlockStatement* body) {
+    const ast::ForLoopStatement* For(
+        const Source& source,
+        const ast::Statement* init,
+        COND&& cond,
+        const ast::Statement* cont,
+        const ast::BlockStatement* body,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
         return create<ast::ForLoopStatement>(source, init, Expr(std::forward<COND>(cond)), cont,
-                                             body);
+                                             body, std::move(attributes));
     }
 
-    /// Creates a ast::ForLoopStatement with input body and optional initializer,
-    /// condition and continuing.
+    /// Creates a ast::ForLoopStatement with input body and optional initializer, condition,
+    /// continuing, and attributes.
     /// @param init the optional loop initializer
     /// @param cond the optional loop condition
     /// @param cont the optional loop continuing
     /// @param body the loop body
+    /// @param attributes optional attributes
     /// @returns the for loop statement pointer
     template <typename COND>
-    const ast::ForLoopStatement* For(const ast::Statement* init,
-                                     COND&& cond,
-                                     const ast::Statement* cont,
-                                     const ast::BlockStatement* body) {
-        return create<ast::ForLoopStatement>(init, Expr(std::forward<COND>(cond)), cont, body);
+    const ast::ForLoopStatement* For(
+        const ast::Statement* init,
+        COND&& cond,
+        const ast::Statement* cont,
+        const ast::BlockStatement* body,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
+        return create<ast::ForLoopStatement>(init, Expr(std::forward<COND>(cond)), cont, body,
+                                             std::move(attributes));
     }
 
-    /// Creates a ast::WhileStatement with input body and condition.
+    /// Creates a ast::WhileStatement with input body, condition, and optional attributes.
     /// @param source the source information
     /// @param cond the loop condition
     /// @param body the loop body
+    /// @param attributes optional attributes
     /// @returns the while statement pointer
     template <typename COND>
-    const ast::WhileStatement* While(const Source& source,
-                                     COND&& cond,
-                                     const ast::BlockStatement* body) {
-        return create<ast::WhileStatement>(source, Expr(std::forward<COND>(cond)), body);
+    const ast::WhileStatement* While(
+        const Source& source,
+        COND&& cond,
+        const ast::BlockStatement* body,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
+        return create<ast::WhileStatement>(source, Expr(std::forward<COND>(cond)), body,
+                                           std::move(attributes));
     }
 
-    /// Creates a ast::WhileStatement with given condition and body.
+    /// Creates a ast::WhileStatement with input body, condition, and optional attributes.
     /// @param cond the condition
     /// @param body the loop body
+    /// @param attributes optional attributes
     /// @returns the while loop statement pointer
     template <typename COND>
-    const ast::WhileStatement* While(COND&& cond, const ast::BlockStatement* body) {
-        return create<ast::WhileStatement>(Expr(std::forward<COND>(cond)), body);
+    const ast::WhileStatement* While(
+        COND&& cond,
+        const ast::BlockStatement* body,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
+        return create<ast::WhileStatement>(Expr(std::forward<COND>(cond)), body,
+                                           std::move(attributes));
     }
 
     /// Creates a ast::VariableDeclStatement for the input variable
@@ -3348,14 +3370,15 @@
     /// @param condition the condition expression initializer
     /// @param cases case statements
     /// @returns the switch statement pointer
-    template <typename ExpressionInit, typename... Cases>
+    template <typename ExpressionInit, typename... Cases, typename = DisableIfVectorLike<Cases...>>
     const ast::SwitchStatement* Switch(const Source& source,
                                        ExpressionInit&& condition,
                                        Cases&&... cases) {
         return create<ast::SwitchStatement>(
             source, Expr(std::forward<ExpressionInit>(condition)),
             utils::Vector<const ast::CaseStatement*, sizeof...(cases)>{
-                std::forward<Cases>(cases)...});
+                std::forward<Cases>(cases)...},
+            utils::Empty);
     }
 
     /// Creates a ast::SwitchStatement with input expression and cases
@@ -3364,12 +3387,44 @@
     /// @returns the switch statement pointer
     template <typename ExpressionInit,
               typename... Cases,
-              typename = DisableIfSource<ExpressionInit>>
+              typename = DisableIfSource<ExpressionInit>,
+              typename = DisableIfVectorLike<Cases...>>
     const ast::SwitchStatement* Switch(ExpressionInit&& condition, Cases&&... cases) {
         return create<ast::SwitchStatement>(
             Expr(std::forward<ExpressionInit>(condition)),
             utils::Vector<const ast::CaseStatement*, sizeof...(cases)>{
-                std::forward<Cases>(cases)...});
+                std::forward<Cases>(cases)...},
+            utils::Empty);
+    }
+
+    /// Creates a ast::SwitchStatement with input expression, cases, and optional attributes
+    /// @param source the source information
+    /// @param condition the condition expression initializer
+    /// @param cases case statements
+    /// @param attributes optional attributes
+    /// @returns the switch statement pointer
+    template <typename ExpressionInit>
+    const ast::SwitchStatement* Switch(
+        const Source& source,
+        ExpressionInit&& condition,
+        utils::VectorRef<const ast::CaseStatement*> cases,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
+        return create<ast::SwitchStatement>(source, Expr(std::forward<ExpressionInit>(condition)),
+                                            cases, std::move(attributes));
+    }
+
+    /// Creates a ast::SwitchStatement with input expression, cases, and optional attributes
+    /// @param condition the condition expression initializer
+    /// @param cases case statements
+    /// @param attributes optional attributes
+    /// @returns the switch statement pointer
+    template <typename ExpressionInit, typename = DisableIfSource<ExpressionInit>>
+    const ast::SwitchStatement* Switch(
+        ExpressionInit&& condition,
+        utils::VectorRef<const ast::CaseStatement*> cases,
+        utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
+        return create<ast::SwitchStatement>(Expr(std::forward<ExpressionInit>(condition)), cases,
+                                            std::move(attributes));
     }
 
     /// Creates a ast::CaseStatement with input list of selectors, and body
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index 49d4e83..7ec46e7 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -32,7 +32,8 @@
 #include "src/tint/ast/unary_op_expression.h"
 #include "src/tint/ast/variable_decl_statement.h"
 #include "src/tint/builtin/builtin_value.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/spirv_atomic.h"
 #include "src/tint/type/depth_texture.h"
 #include "src/tint/type/sampled_texture.h"
@@ -452,42 +453,42 @@
 }
 
 // Returns the WGSL standard library function builtin for the
-// given instruction, or sem::BuiltinType::kNone
-sem::BuiltinType GetBuiltin(spv::Op opcode) {
+// given instruction, or builtin::Function::kNone
+builtin::Function GetBuiltin(spv::Op opcode) {
     switch (opcode) {
         case spv::Op::OpBitCount:
-            return sem::BuiltinType::kCountOneBits;
+            return builtin::Function::kCountOneBits;
         case spv::Op::OpBitFieldInsert:
-            return sem::BuiltinType::kInsertBits;
+            return builtin::Function::kInsertBits;
         case spv::Op::OpBitFieldSExtract:
         case spv::Op::OpBitFieldUExtract:
-            return sem::BuiltinType::kExtractBits;
+            return builtin::Function::kExtractBits;
         case spv::Op::OpBitReverse:
-            return sem::BuiltinType::kReverseBits;
+            return builtin::Function::kReverseBits;
         case spv::Op::OpDot:
-            return sem::BuiltinType::kDot;
+            return builtin::Function::kDot;
         case spv::Op::OpDPdx:
-            return sem::BuiltinType::kDpdx;
+            return builtin::Function::kDpdx;
         case spv::Op::OpDPdy:
-            return sem::BuiltinType::kDpdy;
+            return builtin::Function::kDpdy;
         case spv::Op::OpFwidth:
-            return sem::BuiltinType::kFwidth;
+            return builtin::Function::kFwidth;
         case spv::Op::OpDPdxFine:
-            return sem::BuiltinType::kDpdxFine;
+            return builtin::Function::kDpdxFine;
         case spv::Op::OpDPdyFine:
-            return sem::BuiltinType::kDpdyFine;
+            return builtin::Function::kDpdyFine;
         case spv::Op::OpFwidthFine:
-            return sem::BuiltinType::kFwidthFine;
+            return builtin::Function::kFwidthFine;
         case spv::Op::OpDPdxCoarse:
-            return sem::BuiltinType::kDpdxCoarse;
+            return builtin::Function::kDpdxCoarse;
         case spv::Op::OpDPdyCoarse:
-            return sem::BuiltinType::kDpdyCoarse;
+            return builtin::Function::kDpdyCoarse;
         case spv::Op::OpFwidthCoarse:
-            return sem::BuiltinType::kFwidthCoarse;
+            return builtin::Function::kFwidthCoarse;
         default:
             break;
     }
-    return sem::BuiltinType::kNone;
+    return builtin::Function::kNone;
 }
 
 // @param opcode a SPIR-V opcode
@@ -705,8 +706,8 @@
         auto reversed_cases = cases;
         std::reverse(reversed_cases.begin(), reversed_cases.end());
 
-        return builder->create<ast::SwitchStatement>(Source{}, condition,
-                                                     std::move(reversed_cases));
+        return builder->create<ast::SwitchStatement>(Source{}, condition, std::move(reversed_cases),
+                                                     utils::Empty);
     }
 
     /// Switch statement condition
@@ -725,7 +726,7 @@
     /// @param builder the program builder
     /// @returns the built ast::IfStatement
     const ast::IfStatement* Build(ProgramBuilder* builder) const override {
-        return builder->create<ast::IfStatement>(Source{}, cond, body, else_stmt);
+        return builder->create<ast::IfStatement>(Source{}, cond, body, else_stmt, utils::Empty);
     }
 
     /// If-statement condition
@@ -3324,7 +3325,8 @@
         else_block = create<ast::BlockStatement>(StatementList{else_stmt}, utils::Empty);
     }
 
-    auto* if_stmt = create<ast::IfStatement>(Source{}, condition, if_block, else_block);
+    auto* if_stmt =
+        create<ast::IfStatement>(Source{}, condition, if_block, else_block, utils::Empty);
 
     return if_stmt;
 }
@@ -3816,7 +3818,7 @@
     }
 
     const auto builtin = GetBuiltin(op);
-    if (builtin != sem::BuiltinType::kNone) {
+    if (builtin != builtin::Function::kNone) {
         return MakeBuiltinCall(inst);
     }
 
@@ -5250,7 +5252,7 @@
 
 TypedExpression FunctionEmitter::MakeBuiltinCall(const spvtools::opt::Instruction& inst) {
     const auto builtin = GetBuiltin(opcode(inst));
-    auto* name = sem::str(builtin);
+    auto* name = builtin::str(builtin);
     auto* ident = create<ast::Identifier>(Source{}, builder_.Symbols().Register(name));
 
     ExpressionList params;
@@ -5741,7 +5743,7 @@
 }
 
 bool FunctionEmitter::EmitAtomicOp(const spvtools::opt::Instruction& inst) {
-    auto emit_atomic = [&](sem::BuiltinType builtin, std::initializer_list<TypedExpression> args) {
+    auto emit_atomic = [&](builtin::Function builtin, std::initializer_list<TypedExpression> args) {
         // Split args into params and expressions
         ParameterList params;
         params.Reserve(args.size());
@@ -5763,7 +5765,7 @@
 
         // Emit stub, will be removed by transform::SpirvAtomic
         auto* stub = builder_.Func(
-            Source{}, builder_.Symbols().New(std::string("stub_") + sem::str(builtin)),
+            Source{}, builder_.Symbols().New(std::string("stub_") + builtin::str(builtin)),
             std::move(params), ret_type,
             /* body */ nullptr,
             utils::Vector{
@@ -5800,39 +5802,39 @@
 
     switch (opcode(inst)) {
         case spv::Op::OpAtomicLoad:
-            return emit_atomic(sem::BuiltinType::kAtomicLoad, {oper(/*ptr*/ 0)});
+            return emit_atomic(builtin::Function::kAtomicLoad, {oper(/*ptr*/ 0)});
         case spv::Op::OpAtomicStore:
-            return emit_atomic(sem::BuiltinType::kAtomicStore,
+            return emit_atomic(builtin::Function::kAtomicStore,
                                {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicExchange:
-            return emit_atomic(sem::BuiltinType::kAtomicExchange,
+            return emit_atomic(builtin::Function::kAtomicExchange,
                                {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicCompareExchange:
         case spv::Op::OpAtomicCompareExchangeWeak:
-            return emit_atomic(sem::BuiltinType::kAtomicCompareExchangeWeak,
+            return emit_atomic(builtin::Function::kAtomicCompareExchangeWeak,
                                {oper(/*ptr*/ 0), /*value*/ oper(5), /*comparator*/ oper(4)});
         case spv::Op::OpAtomicIIncrement:
-            return emit_atomic(sem::BuiltinType::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
+            return emit_atomic(builtin::Function::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
         case spv::Op::OpAtomicIDecrement:
-            return emit_atomic(sem::BuiltinType::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
+            return emit_atomic(builtin::Function::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
         case spv::Op::OpAtomicIAdd:
-            return emit_atomic(sem::BuiltinType::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicISub:
-            return emit_atomic(sem::BuiltinType::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicSMin:
-            return emit_atomic(sem::BuiltinType::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicUMin:
-            return emit_atomic(sem::BuiltinType::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicSMax:
-            return emit_atomic(sem::BuiltinType::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicUMax:
-            return emit_atomic(sem::BuiltinType::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicAnd:
-            return emit_atomic(sem::BuiltinType::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicOr:
-            return emit_atomic(sem::BuiltinType::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicXor:
-            return emit_atomic(sem::BuiltinType::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+            return emit_atomic(builtin::Function::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
         case spv::Op::OpAtomicFlagTestAndSet:
         case spv::Op::OpAtomicFlagClear:
         case spv::Op::OpAtomicFMinEXT:
diff --git a/src/tint/reader/spirv/parser_impl.cc b/src/tint/reader/spirv/parser_impl.cc
index a1c9042..9f5afdb 100644
--- a/src/tint/reader/spirv/parser_impl.cc
+++ b/src/tint/reader/spirv/parser_impl.cc
@@ -26,6 +26,7 @@
 #include "src/tint/ast/interpolate_attribute.h"
 #include "src/tint/ast/unary_op_expression.h"
 #include "src/tint/reader/spirv/function.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/depth_texture.h"
 #include "src/tint/type/multisampled_texture.h"
 #include "src/tint/type/sampled_texture.h"
diff --git a/src/tint/reader/spirv/parser_impl_barrier_test.cc b/src/tint/reader/spirv/parser_impl_barrier_test.cc
index a594098..ef8e5af 100644
--- a/src/tint/reader/spirv/parser_impl_barrier_test.cc
+++ b/src/tint/reader/spirv/parser_impl_barrier_test.cc
@@ -73,7 +73,7 @@
     ASSERT_NE(sem_call, nullptr);
     auto* builtin = sem_call->Target()->As<sem::Builtin>();
     ASSERT_NE(builtin, nullptr);
-    EXPECT_EQ(builtin->Type(), sem::BuiltinType::kWorkgroupBarrier);
+    EXPECT_EQ(builtin->Type(), builtin::Function::kWorkgroupBarrier);
 }
 
 TEST_F(SpvParserTest, StorageBarrier) {
@@ -106,7 +106,7 @@
     ASSERT_NE(sem_call, nullptr);
     auto* builtin = sem_call->Target()->As<sem::Builtin>();
     ASSERT_NE(builtin, nullptr);
-    EXPECT_EQ(builtin->Type(), sem::BuiltinType::kStorageBarrier);
+    EXPECT_EQ(builtin->Type(), builtin::Function::kStorageBarrier);
 }
 
 TEST_F(SpvParserTest, ErrBarrierInvalidExecution) {
diff --git a/src/tint/reader/spirv/parser_impl_test_helper.cc b/src/tint/reader/spirv/parser_impl_test_helper.cc
index 754922c..2a19c3d 100644
--- a/src/tint/reader/spirv/parser_impl_test_helper.cc
+++ b/src/tint/reader/spirv/parser_impl_test_helper.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "src/tint/reader/spirv/parser_impl_test_helper.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/string_stream.h"
 #include "src/tint/writer/wgsl/generator_impl.h"
 
diff --git a/src/tint/reader/spirv/parser_type.cc b/src/tint/reader/spirv/parser_type.cc
index 71482ff..bc8bd93 100644
--- a/src/tint/reader/spirv/parser_type.cc
+++ b/src/tint/reader/spirv/parser_type.cc
@@ -19,6 +19,7 @@
 #include <utility>
 
 #include "src/tint/program_builder.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/texture_dimension.h"
 #include "src/tint/utils/hash.h"
 #include "src/tint/utils/map.h"
diff --git a/src/tint/reader/wgsl/lexer.cc b/src/tint/reader/wgsl/lexer.cc
index 28fb135..91c2993 100644
--- a/src/tint/reader/wgsl/lexer.cc
+++ b/src/tint/reader/wgsl/lexer.cc
@@ -25,6 +25,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/strings/charconv.h"
 #include "src/tint/debug.h"
 #include "src/tint/number.h"
 #include "src/tint/text/unicode.h"
@@ -352,9 +353,11 @@
 
     // Parse the exponent if one exists
     bool has_exponent = false;
+    bool negative_exponent = false;
     if (end < length() && (matches(end, 'e') || matches(end, 'E'))) {
         end++;
         if (end < length() && (matches(end, '+') || matches(end, '-'))) {
+            negative_exponent = matches(end, '-');
             end++;
         }
 
@@ -374,10 +377,8 @@
     bool has_f_suffix = false;
     bool has_h_suffix = false;
     if (end < length() && matches(end, 'f')) {
-        end++;
         has_f_suffix = true;
     } else if (end < length() && matches(end, 'h')) {
-        end++;
         has_h_suffix = true;
     }
 
@@ -386,29 +387,51 @@
         return {};
     }
 
-    advance(end - start);
-    end_source(source);
+    // Note, the `at` method will return a static `0` if the provided position is >= length. We
+    // actually need the end pointer to point to the correct memory location to use `from_chars`.
+    // So, handle the case where we point past the length specially.
+    auto* end_ptr = &at(end);
+    if (end >= length()) {
+        end_ptr = &at(length() - 1) + 1;
+    }
 
-    double value = std::strtod(&at(start), nullptr);
+    double value = 0;
+    auto ret = absl::from_chars(&at(start), end_ptr, value);
+    bool overflow = ret.ec != std::errc();
+
+    // The provided value did not fit in a double and has a negative exponent, so treat it as a 0.
+    if (negative_exponent && ret.ec == std::errc::result_out_of_range) {
+        overflow = false;
+        value = 0.0;
+    }
+
+    TINT_ASSERT(Reader, end_ptr == ret.ptr);
+    advance(end - start);
 
     if (has_f_suffix) {
-        if (auto f = CheckedConvert<f32>(AFloat(value))) {
+        auto f = CheckedConvert<f32>(AFloat(value));
+        if (!overflow && f) {
+            advance(1);
+            end_source(source);
             return {Token::Type::kFloatLiteral_F, source, static_cast<double>(f.Get())};
-        } else {
-            return {Token::Type::kError, source, "value cannot be represented as 'f32'"};
         }
+        return {Token::Type::kError, source, "value cannot be represented as 'f32'"};
     }
 
     if (has_h_suffix) {
-        if (auto f = CheckedConvert<f16>(AFloat(value))) {
+        auto f = CheckedConvert<f16>(AFloat(value));
+        if (!overflow && f) {
+            advance(1);
+            end_source(source);
             return {Token::Type::kFloatLiteral_H, source, static_cast<double>(f.Get())};
-        } else {
-            return {Token::Type::kError, source, "value cannot be represented as 'f16'"};
         }
+        return {Token::Type::kError, source, "value cannot be represented as 'f16'"};
     }
 
+    end_source(source);
+
     TINT_BEGIN_DISABLE_WARNING(FLOAT_EQUAL);
-    if (value == HUGE_VAL || -value == HUGE_VAL) {
+    if (overflow || value == HUGE_VAL || -value == HUGE_VAL) {
         return {Token::Type::kError, source, "value cannot be represented as 'abstract-float'"};
     } else {
         return {Token::Type::kFloatLiteral, source, value};
diff --git a/src/tint/reader/wgsl/lexer_test.cc b/src/tint/reader/wgsl/lexer_test.cc
index 95b43a7..a244273 100644
--- a/src/tint/reader/wgsl/lexer_test.cc
+++ b/src/tint/reader/wgsl/lexer_test.cc
@@ -397,7 +397,7 @@
     Lexer l(&file);
 
     auto list = l.Lex();
-    ASSERT_EQ(2u, list.size());
+    ASSERT_EQ(2u, list.size()) << "Got: " << list[0].to_str();
 
     {
         auto& t = list[0];
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index e4eab29..6864084 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -42,6 +42,7 @@
 #include "src/tint/type/multisampled_texture.h"
 #include "src/tint/type/sampled_texture.h"
 #include "src/tint/type/texture_dimension.h"
+#include "src/tint/utils/defer.h"
 #include "src/tint/utils/reverse.h"
 #include "src/tint/utils/string.h"
 #include "src/tint/utils/string_stream.h"
@@ -72,21 +73,19 @@
 
 // https://gpuweb.github.io/gpuweb/wgsl.html#reserved-keywords
 bool is_reserved(const Token& t) {
-    return t == "CompileShader" || t == "ComputeShader" || t == "DomainShader" ||
-           t == "GeometryShader" || t == "Hullshader" || t == "NULL" || t == "Self" ||
-           t == "abstract" || t == "active" || t == "alignas" || t == "alignof" || t == "as" ||
-           t == "asm" || t == "asm_fragment" || t == "async" || t == "attribute" || t == "auto" ||
-           t == "await" || t == "become" || t == "binding_array" || t == "cast" || t == "catch" ||
-           t == "class" || t == "co_await" || t == "co_return" || t == "co_yield" ||
-           t == "coherent" || t == "column_major" || t == "common" || t == "compile" ||
-           t == "compile_fragment" || t == "concept" || t == "const_cast" || t == "consteval" ||
-           t == "constexpr" || t == "constinit" || t == "crate" || t == "debugger" ||
-           t == "decltype" || t == "delete" || t == "demote" || t == "demote_to_helper" ||
-           t == "do" || t == "dynamic_cast" || t == "enum" || t == "explicit" || t == "export" ||
-           t == "extends" || t == "extern" || t == "external" || t == "filter" || t == "final" ||
-           t == "finally" || t == "friend" || t == "from" || t == "fxgroup" || t == "get" ||
-           t == "goto" || t == "groupshared" || t == "handle" || t == "highp" || t == "impl" ||
-           t == "implements" || t == "import" || t == "inline" || t == "inout" ||
+    return t == "NULL" || t == "Self" || t == "abstract" || t == "active" || t == "alignas" ||
+           t == "alignof" || t == "as" || t == "asm" || t == "asm_fragment" || t == "async" ||
+           t == "attribute" || t == "auto" || t == "await" || t == "become" ||
+           t == "binding_array" || t == "cast" || t == "catch" || t == "class" || t == "co_await" ||
+           t == "co_return" || t == "co_yield" || t == "coherent" || t == "column_major" ||
+           t == "common" || t == "compile" || t == "compile_fragment" || t == "concept" ||
+           t == "const_cast" || t == "consteval" || t == "constexpr" || t == "constinit" ||
+           t == "crate" || t == "debugger" || t == "decltype" || t == "delete" || t == "demote" ||
+           t == "demote_to_helper" || t == "do" || t == "dynamic_cast" || t == "enum" ||
+           t == "explicit" || t == "export" || t == "extends" || t == "extern" || t == "external" ||
+           t == "filter" || t == "final" || t == "finally" || t == "friend" || t == "from" ||
+           t == "fxgroup" || t == "get" || t == "goto" || t == "groupshared" || t == "highp" ||
+           t == "impl" || t == "implements" || t == "import" || t == "inline" ||
            t == "instanceof" || t == "interface" || t == "layout" || t == "lowp" || t == "macro" ||
            t == "macro_rules" || t == "match" || t == "mediump" || t == "meta" || t == "mod" ||
            t == "module" || t == "move" || t == "mut" || t == "mutable" || t == "namespace" ||
@@ -96,8 +95,8 @@
            t == "partition" || t == "pass" || t == "patch" || t == "pixelfragment" ||
            t == "precise" || t == "precision" || t == "premerge" || t == "priv" ||
            t == "protected" || t == "pub" || t == "public" || t == "readonly" || t == "ref" ||
-           t == "regardless" || t == "register" || t == "reinterpret_cast" || t == "resource" ||
-           t == "restrict" || t == "self" || t == "set" || t == "shared" || t == "signed" ||
+           t == "regardless" || t == "register" || t == "reinterpret_cast" || t == "require" ||
+           t == "resource" || t == "restrict" || t == "self" || t == "set" || t == "shared" ||
            t == "sizeof" || t == "smooth" || t == "snorm" || t == "static" ||
            t == "static_assert" || t == "static_cast" || t == "std" || t == "subroutine" ||
            t == "super" || t == "target" || t == "template" || t == "this" || t == "thread_local" ||
@@ -391,53 +390,52 @@
     return decl;
 }
 
-// enable_directive
-//  : enable name SEMICLON
+// enable_directive :
+// | 'enable' identifier (COMMA identifier)* COMMA? SEMICOLON
 Maybe<Void> ParserImpl::enable_directive() {
-    auto decl = sync(Token::Type::kSemicolon, [&]() -> Maybe<Void> {
+    return sync(Token::Type::kSemicolon, [&]() -> Maybe<Void> {
+        MultiTokenSource decl_source(this);
         if (!match(Token::Type::kEnable)) {
             return Failure::kNoMatch;
         }
 
-        // Match the extension name.
-        auto& t = peek();
-        if (handle_error(t)) {
-            // The token might itself be an error.
-            return Failure::kErrored;
-        }
-
-        if (t.Is(Token::Type::kParenLeft)) {
+        if (peek_is(Token::Type::kParenLeft)) {
             // A common error case is writing `enable(foo);` instead of `enable foo;`.
             synchronized_ = false;
-            return add_error(t.source(), "enable directives don't take parenthesis");
+            return add_error(peek().source(), "enable directives don't take parenthesis");
         }
 
-        auto ext = expect_enum("extension", builtin::ParseExtension, builtin::kExtensionStrings);
-        if (ext.errored) {
-            return Failure::kErrored;
+        utils::Vector<const ast::Extension*, 4> extensions;
+        while (continue_parsing()) {
+            Source ext_src = peek().source();
+            auto ext =
+                expect_enum("extension", builtin::ParseExtension, builtin::kExtensionStrings);
+            if (ext.errored) {
+                return Failure::kErrored;
+            }
+            extensions.Push(create<ast::Extension>(ext_src, ext.value));
+
+            if (!match(Token::Type::kComma)) {
+                break;
+            }
+            if (peek_is(Token::Type::kSemicolon)) {
+                break;
+            }
         }
 
         if (!expect("enable directive", Token::Type::kSemicolon)) {
             return Failure::kErrored;
         }
-        builder_.AST().AddEnable(create<ast::Enable>(t.source(), ext.value));
+
+        builder_.AST().AddEnable(create<ast::Enable>(decl_source.Source(), std::move(extensions)));
         return kSuccess;
     });
-
-    if (decl.errored) {
-        return Failure::kErrored;
-    }
-    if (decl.matched) {
-        return kSuccess;
-    }
-
-    return Failure::kNoMatch;
 }
 
 // requires_directive
-//  : require identifier (COMMA identifier)? SEMICLON
+//  : require identifier (COMMA identifier)* COMMA? SEMICOLON
 Maybe<Void> ParserImpl::requires_directive() {
-    auto decl = sync(Token::Type::kSemicolon, [&]() -> Maybe<Void> {
+    return sync(Token::Type::kSemicolon, [&]() -> Maybe<Void> {
         if (!match(Token::Type::kRequires)) {
             return Failure::kNoMatch;
         }
@@ -484,15 +482,6 @@
         // conditional.
         return add_error(t.source(), "missing feature names in requires directive");
     });
-
-    if (decl.errored) {
-        return Failure::kErrored;
-    }
-    if (decl.matched) {
-        return kSuccess;
-    }
-
-    return Failure::kNoMatch;
 }
 
 // global_decl
@@ -1265,7 +1254,7 @@
         return stmt;
     }
 
-    auto stmt_if = if_statement();
+    auto stmt_if = if_statement(attrs.value);
     if (stmt_if.errored) {
         return Failure::kErrored;
     }
@@ -1273,7 +1262,7 @@
         return stmt_if.value;
     }
 
-    auto sw = switch_statement();
+    auto sw = switch_statement(attrs.value);
     if (sw.errored) {
         return Failure::kErrored;
     }
@@ -1289,7 +1278,7 @@
         return loop.value;
     }
 
-    auto stmt_for = for_statement();
+    auto stmt_for = for_statement(attrs.value);
     if (stmt_for.errored) {
         return Failure::kErrored;
     }
@@ -1297,7 +1286,7 @@
         return stmt_for.value;
     }
 
-    auto stmt_while = while_statement();
+    auto stmt_while = while_statement(attrs.value);
     if (stmt_while.errored) {
         return Failure::kErrored;
     }
@@ -1517,11 +1506,14 @@
 }
 
 // if_statement
-//   : IF expression compound_stmt ( ELSE else_stmt ) ?
-// else_stmt
-//  : compound_statement
-//  | if_statement
-Maybe<const ast::IfStatement*> ParserImpl::if_statement() {
+//   : attribute* if_clause else_if_clause* else_clause?
+// if_clause:
+//   : IF expression compound_stmt
+// else_if_clause:
+//   : ELSE IF expression compound_stmt
+// else_clause
+//   : ELSE compound_statement
+Maybe<const ast::IfStatement*> ParserImpl::if_statement(AttributeList& attrs) {
     // Parse if-else chains iteratively instead of recursively, to avoid
     // stack-overflow for long chains of if-else statements.
 
@@ -1529,6 +1521,7 @@
         Source source;
         const ast::Expression* condition;
         const ast::BlockStatement* body;
+        AttributeList attributes;
     };
 
     // Parse an if statement, capturing the source, condition, and body statement.
@@ -1551,7 +1544,8 @@
             return Failure::kErrored;
         }
 
-        return IfInfo{source, condition.value, body.value};
+        TINT_DEFER(attrs.Clear());
+        return IfInfo{source, condition.value, body.value, std::move(attrs)};
     };
 
     std::vector<IfInfo> statements;
@@ -1592,15 +1586,16 @@
 
     // Now walk back through the statements to create their AST nodes.
     for (auto itr = statements.rbegin(); itr != statements.rend(); itr++) {
-        last_stmt = create<ast::IfStatement>(itr->source, itr->condition, itr->body, last_stmt);
+        last_stmt = create<ast::IfStatement>(itr->source, itr->condition, itr->body, last_stmt,
+                                             std::move(itr->attributes));
     }
 
     return last_stmt->As<ast::IfStatement>();
 }
 
 // switch_statement
-//   : SWITCH expression BRACKET_LEFT switch_body+ BRACKET_RIGHT
-Maybe<const ast::SwitchStatement*> ParserImpl::switch_statement() {
+//   : attribute* SWITCH expression BRACKET_LEFT switch_body+ BRACKET_RIGHT
+Maybe<const ast::SwitchStatement*> ParserImpl::switch_statement(AttributeList& attrs) {
     Source source;
     if (!match(Token::Type::kSwitch, &source)) {
         return Failure::kNoMatch;
@@ -1638,7 +1633,8 @@
         return Failure::kErrored;
     }
 
-    return create<ast::SwitchStatement>(source, condition.value, body.value);
+    TINT_DEFER(attrs.Clear());
+    return create<ast::SwitchStatement>(source, condition.value, body.value, std::move(attrs));
 }
 
 // switch_body
@@ -1875,7 +1871,7 @@
 
 // for_statement
 //   : FOR PAREN_LEFT for_header PAREN_RIGHT compound_statement
-Maybe<const ast::ForLoopStatement*> ParserImpl::for_statement() {
+Maybe<const ast::ForLoopStatement*> ParserImpl::for_statement(AttributeList& attrs) {
     Source source;
     if (!match(Token::Type::kFor, &source)) {
         return Failure::kNoMatch;
@@ -1891,13 +1887,14 @@
         return Failure::kErrored;
     }
 
+    TINT_DEFER(attrs.Clear());
     return create<ast::ForLoopStatement>(source, header->initializer, header->condition,
-                                         header->continuing, body.value);
+                                         header->continuing, body.value, std::move(attrs));
 }
 
 // while_statement
-//   :  WHILE expression compound_statement
-Maybe<const ast::WhileStatement*> ParserImpl::while_statement() {
+//   :  attribute* WHILE expression compound_statement
+Maybe<const ast::WhileStatement*> ParserImpl::while_statement(AttributeList& attrs) {
     Source source;
     if (!match(Token::Type::kWhile, &source)) {
         return Failure::kNoMatch;
@@ -1916,7 +1913,8 @@
         return Failure::kErrored;
     }
 
-    return create<ast::WhileStatement>(source, condition.value, body.value);
+    TINT_DEFER(attrs.Clear());
+    return create<ast::WhileStatement>(source, condition.value, body.value, std::move(attrs));
 }
 
 // func_call_statement
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index bfc2f9a..9693ea4 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -488,12 +488,14 @@
     /// Parses a `variable_statement` grammar element
     /// @returns the parsed variable or nullptr
     Maybe<const ast::VariableDeclStatement*> variable_statement();
-    /// Parses a `if_statement` grammar element
+    /// Parses a `if_statement` grammar element, with the attribute list provided as `attrs`.
+    /// @param attrs the list of attributes for the statement
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::IfStatement*> if_statement();
+    Maybe<const ast::IfStatement*> if_statement(AttributeList& attrs);
     /// Parses a `switch_statement` grammar element
+    /// @param attrs the list of attributes for the statement
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::SwitchStatement*> switch_statement();
+    Maybe<const ast::SwitchStatement*> switch_statement(AttributeList& attrs);
     /// Parses a `switch_body` grammar element
     /// @returns the parsed statement or nullptr
     Maybe<const ast::CaseStatement*> switch_body();
@@ -515,12 +517,14 @@
     /// Parses a `for_header` grammar element, erroring on parse failure.
     /// @returns the parsed for header or nullptr
     Expect<std::unique_ptr<ForHeader>> expect_for_header();
-    /// Parses a `for_statement` grammar element
+    /// Parses a `for_statement` grammar element, with the attribute list provided as `attrs`.
+    /// @param attrs the list of attributes for the statement
     /// @returns the parsed for loop or nullptr
-    Maybe<const ast::ForLoopStatement*> for_statement();
-    /// Parses a `while_statement` grammar element
+    Maybe<const ast::ForLoopStatement*> for_statement(AttributeList& attrs);
+    /// Parses a `while_statement` grammar element, with the attribute list provided as `attrs`.
+    /// @param attrs the list of attributes for the statement
     /// @returns the parsed while loop or nullptr
-    Maybe<const ast::WhileStatement*> while_statement();
+    Maybe<const ast::WhileStatement*> while_statement(AttributeList& attrs);
     /// Parses a `break_if_statement` grammar element
     /// @returns the parsed statement or nullptr
     Maybe<const ast::Statement*> break_if_statement();
diff --git a/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc b/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
index 7ad39c2..3c63a02 100644
--- a/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
@@ -22,7 +22,7 @@
 using EnableDirectiveTest = ParserImplTest;
 
 // Test a valid enable directive.
-TEST_F(EnableDirectiveTest, Valid) {
+TEST_F(EnableDirectiveTest, Single) {
     auto p = parser("enable f16;");
     p->enable_directive();
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -30,13 +30,105 @@
     auto& ast = program.AST();
     ASSERT_EQ(ast.Enables().Length(), 1u);
     auto* enable = ast.Enables()[0];
-    EXPECT_EQ(enable->extension, builtin::Extension::kF16);
+    EXPECT_EQ(enable->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->source.range.begin.column, 1u);
+    EXPECT_EQ(enable->source.range.end.line, 1u);
+    EXPECT_EQ(enable->source.range.end.column, 12u);
+    ASSERT_EQ(enable->extensions.Length(), 1u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
+    ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
+    EXPECT_EQ(ast.GlobalDeclarations()[0], enable);
+}
+
+// Test a valid enable directive.
+TEST_F(EnableDirectiveTest, SingleTrailingComma) {
+    auto p = parser("enable f16, ;");
+    p->enable_directive();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    auto program = p->program();
+    auto& ast = program.AST();
+    ASSERT_EQ(ast.Enables().Length(), 1u);
+    auto* enable = ast.Enables()[0];
+    EXPECT_EQ(enable->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->source.range.begin.column, 1u);
+    EXPECT_EQ(enable->source.range.end.line, 1u);
+    EXPECT_EQ(enable->source.range.end.column, 14u);
+    ASSERT_EQ(enable->extensions.Length(), 1u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
+    ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
+    EXPECT_EQ(ast.GlobalDeclarations()[0], enable);
+}
+
+// Test a valid enable directive with multiple extensions.
+TEST_F(EnableDirectiveTest, Multiple) {
+    auto p =
+        parser("enable f16, chromium_disable_uniformity_analysis, chromium_experimental_dp4a;");
+    p->enable_directive();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    auto program = p->program();
+    auto& ast = program.AST();
+    ASSERT_EQ(ast.Enables().Length(), 1u);
+    auto* enable = ast.Enables()[0];
+    ASSERT_EQ(enable->extensions.Length(), 3u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
+    EXPECT_EQ(enable->extensions[1]->name, builtin::Extension::kChromiumDisableUniformityAnalysis);
+    EXPECT_EQ(enable->extensions[1]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[1]->source.range.begin.column, 13u);
+    EXPECT_EQ(enable->extensions[1]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[1]->source.range.end.column, 49u);
+    EXPECT_EQ(enable->extensions[2]->name, builtin::Extension::kChromiumExperimentalDp4A);
+    EXPECT_EQ(enable->extensions[2]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[2]->source.range.begin.column, 51u);
+    EXPECT_EQ(enable->extensions[2]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[2]->source.range.end.column, 77u);
+    ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
+    EXPECT_EQ(ast.GlobalDeclarations()[0], enable);
+}
+
+// Test a valid enable directive with multiple extensions.
+TEST_F(EnableDirectiveTest, MultipleTrailingComma) {
+    auto p =
+        parser("enable f16, chromium_disable_uniformity_analysis, chromium_experimental_dp4a,;");
+    p->enable_directive();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    auto program = p->program();
+    auto& ast = program.AST();
+    ASSERT_EQ(ast.Enables().Length(), 1u);
+    auto* enable = ast.Enables()[0];
+    ASSERT_EQ(enable->extensions.Length(), 3u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
+    EXPECT_EQ(enable->extensions[1]->name, builtin::Extension::kChromiumDisableUniformityAnalysis);
+    EXPECT_EQ(enable->extensions[1]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[1]->source.range.begin.column, 13u);
+    EXPECT_EQ(enable->extensions[1]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[1]->source.range.end.column, 49u);
+    EXPECT_EQ(enable->extensions[2]->name, builtin::Extension::kChromiumExperimentalDp4A);
+    EXPECT_EQ(enable->extensions[2]->source.range.begin.line, 1u);
+    EXPECT_EQ(enable->extensions[2]->source.range.begin.column, 51u);
+    EXPECT_EQ(enable->extensions[2]->source.range.end.line, 1u);
+    EXPECT_EQ(enable->extensions[2]->source.range.end.column, 77u);
     ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
     EXPECT_EQ(ast.GlobalDeclarations()[0], enable);
 }
 
 // Test multiple enable directives for a same extension.
-TEST_F(EnableDirectiveTest, EnableMultipleTime) {
+TEST_F(EnableDirectiveTest, EnableSameLine) {
     auto p = parser(R"(
 enable f16;
 enable f16;
@@ -48,8 +140,18 @@
     ASSERT_EQ(ast.Enables().Length(), 2u);
     auto* enable_a = ast.Enables()[0];
     auto* enable_b = ast.Enables()[1];
-    EXPECT_EQ(enable_a->extension, builtin::Extension::kF16);
-    EXPECT_EQ(enable_b->extension, builtin::Extension::kF16);
+    ASSERT_EQ(enable_a->extensions.Length(), 1u);
+    EXPECT_EQ(enable_a->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable_a->extensions[0]->source.range.begin.line, 2u);
+    EXPECT_EQ(enable_a->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable_a->extensions[0]->source.range.end.line, 2u);
+    EXPECT_EQ(enable_a->extensions[0]->source.range.end.column, 11u);
+    ASSERT_EQ(enable_b->extensions.Length(), 1u);
+    EXPECT_EQ(enable_b->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable_b->extensions[0]->source.range.begin.line, 3u);
+    EXPECT_EQ(enable_b->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable_b->extensions[0]->source.range.end.line, 3u);
+    EXPECT_EQ(enable_b->extensions[0]->source.range.end.column, 11u);
     ASSERT_EQ(ast.GlobalDeclarations().Length(), 2u);
     EXPECT_EQ(ast.GlobalDeclarations()[0], enable_a);
     EXPECT_EQ(ast.GlobalDeclarations()[1], enable_b);
@@ -169,7 +271,12 @@
     // Accept the enable directive although it caused an error
     ASSERT_EQ(ast.Enables().Length(), 1u);
     auto* enable = ast.Enables()[0];
-    EXPECT_EQ(enable->extension, builtin::Extension::kF16);
+    ASSERT_EQ(enable->extensions.Length(), 1u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 3u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 3u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
     ASSERT_EQ(ast.GlobalDeclarations().Length(), 2u);
     EXPECT_EQ(ast.GlobalDeclarations()[1], enable);
 }
@@ -189,7 +296,12 @@
     // Accept the enable directive although it cause an error
     ASSERT_EQ(ast.Enables().Length(), 1u);
     auto* enable = ast.Enables()[0];
-    EXPECT_EQ(enable->extension, builtin::Extension::kF16);
+    ASSERT_EQ(enable->extensions.Length(), 1u);
+    EXPECT_EQ(enable->extensions[0]->name, builtin::Extension::kF16);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.line, 3u);
+    EXPECT_EQ(enable->extensions[0]->source.range.begin.column, 8u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.line, 3u);
+    EXPECT_EQ(enable->extensions[0]->source.range.end.column, 11u);
     ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
     EXPECT_EQ(ast.GlobalDeclarations()[0], enable);
 }
diff --git a/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
index 5af8f22..528be9f 100644
--- a/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
@@ -24,7 +24,8 @@
 // Test an empty for loop.
 TEST_F(ForStmtTest, Empty) {
     auto p = parser("for (;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -37,7 +38,8 @@
 // Test a for loop with non-empty body.
 TEST_F(ForStmtTest, Body) {
     auto p = parser("for (;;) { discard; }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -51,7 +53,8 @@
 // Test a for loop declaring a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementDecl) {
     auto p = parser("for (var i: i32 ;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -68,7 +71,8 @@
 // statement.
 TEST_F(ForStmtTest, InitializerStatementDeclEqual) {
     auto p = parser("for (var i: i32 = 0 ;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -84,7 +88,8 @@
 // Test a for loop declaring a const variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementConstDecl) {
     auto p = parser("for (let i: i32 = 0 ;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -100,7 +105,8 @@
 // Test a for loop assigning a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementAssignment) {
     auto p = parser("for (i = 0 ;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -113,7 +119,8 @@
 // Test a for loop incrementing a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementIncrement) {
     auto p = parser("for (i++;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -126,7 +133,8 @@
 // Test a for loop calling a function in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementFuncCall) {
     auto p = parser("for (a(b,c) ;;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -139,7 +147,8 @@
 // Test a for loop with a break condition
 TEST_F(ForStmtTest, BreakCondition) {
     auto p = parser("for (; 0 == 1;) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -152,7 +161,8 @@
 // Test a for loop assigning a variable in the continuing statement.
 TEST_F(ForStmtTest, ContinuingAssignment) {
     auto p = parser("for (;; x = 2) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -165,7 +175,8 @@
 // Test a for loop with an increment statement as the continuing statement.
 TEST_F(ForStmtTest, ContinuingIncrement) {
     auto p = parser("for (;; x++) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -178,7 +189,8 @@
 // Test a for loop calling a function in the continuing statement.
 TEST_F(ForStmtTest, ContinuingFuncCall) {
     auto p = parser("for (;; a(b,c)) { }");
-    auto fl = p->for_statement();
+    ParserImpl::AttributeList attrs;
+    auto fl = p->for_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -188,11 +200,26 @@
     EXPECT_TRUE(fl->body->Empty());
 }
 
+// Test a for loop with attributes.
+TEST_F(ForStmtTest, WithAttributes) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) for (;;) { }");
+    auto attrs = p->attribute_list();
+    auto fl = p->for_statement(attrs.value);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_FALSE(fl.errored);
+    ASSERT_TRUE(fl.matched);
+
+    EXPECT_TRUE(attrs->IsEmpty());
+    ASSERT_EQ(fl->attributes.Length(), 1u);
+    EXPECT_TRUE(fl->attributes[0]->Is<ast::DiagnosticAttribute>());
+}
+
 class ForStmtErrorTest : public ParserImplTest {
   public:
     void TestForWithError(std::string for_str, std::string error_str) {
         auto p_for = parser(for_str);
-        auto e_for = p_for->for_statement();
+        ParserImpl::AttributeList attrs;
+        auto e_for = p_for->for_statement(attrs);
 
         EXPECT_FALSE(e_for.matched);
         EXPECT_TRUE(e_for.errored);
diff --git a/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
index 55effc7..2acb26c 100644
--- a/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
@@ -19,7 +19,8 @@
 
 TEST_F(ParserImplTest, IfStmt) {
     auto p = parser("if a == 4 { a = b; c = d; }");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -34,7 +35,8 @@
 
 TEST_F(ParserImplTest, IfStmt_WithElse) {
     auto p = parser("if a == 4 { a = b; c = d; } else if(c) { d = 2; } else {}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -57,7 +59,8 @@
 
 TEST_F(ParserImplTest, IfStmt_WithElse_WithParens) {
     auto p = parser("if(a==4) { a = b; c = d; } else if(c) { d = 2; } else {}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -78,9 +81,25 @@
     EXPECT_EQ(el->statements.Length(), 0u);
 }
 
+TEST_F(ParserImplTest, IfStmt_WithAttributes) {
+    auto p = parser(R"(@diagnostic(off, derivative_uniformity) if true { })");
+    auto a = p->attribute_list();
+    auto e = p->if_statement(a.value);
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    ASSERT_NE(e.value, nullptr);
+    ASSERT_TRUE(e->Is<ast::IfStatement>());
+
+    EXPECT_TRUE(a->IsEmpty());
+    ASSERT_EQ(e->attributes.Length(), 1u);
+    EXPECT_TRUE(e->attributes[0]->Is<ast::DiagnosticAttribute>());
+}
+
 TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
     auto p = parser("if a = 3 {}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -90,7 +109,8 @@
 
 TEST_F(ParserImplTest, IfStmt_MissingCondition) {
     auto p = parser("if {}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -100,7 +120,8 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidBody) {
     auto p = parser("if a { fn main() {}}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -110,7 +131,8 @@
 
 TEST_F(ParserImplTest, IfStmt_MissingBody) {
     auto p = parser("if a");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -120,7 +142,8 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidElseif) {
     auto p = parser("if a {} else if a { fn main() -> a{}}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -130,7 +153,8 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidElse) {
     auto p = parser("if a {} else { fn main() -> a{}}");
-    auto e = p->if_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->if_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_reserved_keyword_test.cc b/src/tint/reader/wgsl/parser_impl_reserved_keyword_test.cc
index 647bb44..50f43ea 100644
--- a/src/tint/reader/wgsl/parser_impl_reserved_keyword_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_reserved_keyword_test.cc
@@ -85,11 +85,7 @@
 }
 INSTANTIATE_TEST_SUITE_P(ParserImplReservedKeywordTest,
                          ParserImplReservedKeywordTest,
-                         testing::Values("ComputeShader",
-                                         "DomainShader",
-                                         "GeometryShader",
-                                         "Hullshader",
-                                         "NULL",
+                         testing::Values("NULL",
                                          "Self",
                                          "abstract",
                                          "active",
@@ -143,13 +139,11 @@
                                          "get",
                                          "goto",
                                          "groupshared",
-                                         "handle",
                                          "highp",
                                          "impl",
                                          "implements",
                                          "import",
                                          "inline",
-                                         "inout",
                                          "instanceof",
                                          "interface",
                                          "layout",
@@ -198,7 +192,6 @@
                                          "self",
                                          "set",
                                          "shared",
-                                         "signed",
                                          "sizeof",
                                          "smooth",
                                          "snorm",
diff --git a/src/tint/reader/wgsl/parser_impl_statement_test.cc b/src/tint/reader/wgsl/parser_impl_statement_test.cc
index 634bfb4..8c920a7 100644
--- a/src/tint/reader/wgsl/parser_impl_statement_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_statement_test.cc
@@ -314,6 +314,66 @@
     EXPECT_EQ(sa->condition->source.range.end.column, 19u);
 }
 
+TEST_F(ParserImplTest, Statement_ConsumedAttributes_Block) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) {}");
+    auto e = p->statement();
+    ASSERT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+
+    auto* s = As<ast::BlockStatement>(e.value);
+    ASSERT_NE(s, nullptr);
+    EXPECT_EQ(s->attributes.Length(), 1u);
+}
+
+TEST_F(ParserImplTest, Statement_ConsumedAttributes_For) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) for (;false;) {}");
+    auto e = p->statement();
+    ASSERT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+
+    auto* s = As<ast::ForLoopStatement>(e.value);
+    ASSERT_NE(s, nullptr);
+    EXPECT_EQ(s->attributes.Length(), 1u);
+}
+
+TEST_F(ParserImplTest, Statement_ConsumedAttributes_If) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) if true {}");
+    auto e = p->statement();
+    ASSERT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+
+    auto* s = As<ast::IfStatement>(e.value);
+    ASSERT_NE(s, nullptr);
+    EXPECT_EQ(s->attributes.Length(), 1u);
+}
+
+TEST_F(ParserImplTest, Statement_ConsumedAttributes_Switch) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) switch (0) { default{} }");
+    auto e = p->statement();
+    ASSERT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+
+    auto* s = As<ast::SwitchStatement>(e.value);
+    ASSERT_NE(s, nullptr);
+    EXPECT_EQ(s->attributes.Length(), 1u);
+}
+
+TEST_F(ParserImplTest, Statement_ConsumedAttributes_While) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) while (false) {}");
+    auto e = p->statement();
+    ASSERT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+
+    auto* s = As<ast::WhileStatement>(e.value);
+    ASSERT_NE(s, nullptr);
+    EXPECT_EQ(s->attributes.Length(), 1u);
+}
+
 TEST_F(ParserImplTest, Statement_UnexpectedAttributes) {
     auto p = parser("@diagnostic(off, derivative_uniformity) return;");
     auto e = p->statement();
diff --git a/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
index a5e3dd3..ef0b1b4 100644
--- a/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
@@ -22,7 +22,8 @@
   case 1: {}
   case 2: {}
 })");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -35,7 +36,8 @@
 
 TEST_F(ParserImplTest, SwitchStmt_Empty) {
     auto p = parser("switch a { }");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -50,7 +52,8 @@
   default: {}
   case 2: {}
 })");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -67,7 +70,8 @@
     auto p = parser(R"(switch a {
   case 1, default, 2: {}
 })");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -80,7 +84,8 @@
 
 TEST_F(ParserImplTest, SwitchStmt_WithParens) {
     auto p = parser("switch(a+b) { }");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -89,9 +94,25 @@
     ASSERT_EQ(e->body.Length(), 0u);
 }
 
+TEST_F(ParserImplTest, SwitchStmt_WithAttributes) {
+    auto p = parser(R"(@diagnostic(off, derivative_uniformity) switch a { default{} })");
+    auto a = p->attribute_list();
+    auto e = p->switch_statement(a.value);
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    ASSERT_NE(e.value, nullptr);
+    ASSERT_TRUE(e->Is<ast::SwitchStatement>());
+
+    EXPECT_TRUE(a->IsEmpty());
+    ASSERT_EQ(e->attributes.Length(), 1u);
+    EXPECT_TRUE(e->attributes[0]->Is<ast::DiagnosticAttribute>());
+}
+
 TEST_F(ParserImplTest, SwitchStmt_InvalidExpression) {
     auto p = parser("switch a=b {}");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -101,7 +122,8 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingExpression) {
     auto p = parser("switch {}");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -111,7 +133,8 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketLeft) {
     auto p = parser("switch a }");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -121,7 +144,8 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketRight) {
     auto p = parser("switch a {");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -133,7 +157,8 @@
     auto p = parser(R"(switch a {
   case: {}
 })");
-    auto e = p->switch_statement();
+    ParserImpl::AttributeList attrs;
+    auto e = p->switch_statement(attrs);
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
index d61843e..dcbb59b 100644
--- a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
@@ -24,7 +24,8 @@
 // Test an empty while loop.
 TEST_F(WhileStmtTest, Empty) {
     auto p = parser("while true { }");
-    auto wl = p->while_statement();
+    ParserImpl::AttributeList attrs;
+    auto wl = p->while_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -35,7 +36,8 @@
 // Test an empty while loop with parentheses.
 TEST_F(WhileStmtTest, EmptyWithParentheses) {
     auto p = parser("while (true) { }");
-    auto wl = p->while_statement();
+    ParserImpl::AttributeList attrs;
+    auto wl = p->while_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -46,7 +48,8 @@
 // Test a while loop with non-empty body.
 TEST_F(WhileStmtTest, Body) {
     auto p = parser("while (true) { discard; }");
-    auto wl = p->while_statement();
+    ParserImpl::AttributeList attrs;
+    auto wl = p->while_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -58,7 +61,8 @@
 // Test a while loop with complex condition.
 TEST_F(WhileStmtTest, ComplexCondition) {
     auto p = parser("while (a + 1 - 2) == 3 { }");
-    auto wl = p->while_statement();
+    ParserImpl::AttributeList attrs;
+    auto wl = p->while_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -69,7 +73,8 @@
 // Test a while loop with complex condition, with parentheses.
 TEST_F(WhileStmtTest, ComplexConditionWithParentheses) {
     auto p = parser("while ((a + 1 - 2) == 3) { }");
-    auto wl = p->while_statement();
+    ParserImpl::AttributeList attrs;
+    auto wl = p->while_statement(attrs);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -77,11 +82,26 @@
     EXPECT_TRUE(wl->body->Empty());
 }
 
+// Test a while loop with attributes.
+TEST_F(WhileStmtTest, WithAttributes) {
+    auto p = parser("@diagnostic(off, derivative_uniformity) while true { }");
+    auto attrs = p->attribute_list();
+    auto wl = p->while_statement(attrs.value);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_FALSE(wl.errored);
+    ASSERT_TRUE(wl.matched);
+
+    EXPECT_TRUE(attrs->IsEmpty());
+    ASSERT_EQ(wl->attributes.Length(), 1u);
+    EXPECT_TRUE(wl->attributes[0]->Is<ast::DiagnosticAttribute>());
+}
+
 class WhileStmtErrorTest : public ParserImplTest {
   public:
     void TestWhileWithError(std::string for_str, std::string error_str) {
         auto p_for = parser(for_str);
-        auto e_for = p_for->while_statement();
+        ParserImpl::AttributeList attrs;
+        auto e_for = p_for->while_statement(attrs);
 
         EXPECT_FALSE(e_for.matched);
         EXPECT_TRUE(e_for.errored);
diff --git a/src/tint/reader/wgsl/token.h b/src/tint/reader/wgsl/token.h
index 43f6831..19bdd40 100644
--- a/src/tint/reader/wgsl/token.h
+++ b/src/tint/reader/wgsl/token.h
@@ -165,17 +165,19 @@
         kContinue,
         /// A 'continuing'
         kContinuing,
+        /// A 'default'
+        kDefault,
         /// A 'diagnostic'
         kDiagnostic,
         /// A 'discard'
         kDiscard,
-        /// A 'default'
-        kDefault,
         /// A 'else'
         kElse,
         /// A 'enable'
         kEnable,
         /// A 'fallthrough'
+        // Note, this isn't a keyword, but a reserved word. We match it as a keyword in order to
+        // provide better diagnostics in case a `fallthrough` is added to a case body.
         kFallthrough,
         /// A 'false'
         kFalse,
@@ -191,10 +193,10 @@
         kLoop,
         /// A 'override'
         kOverride,
-        /// A 'return'
-        kReturn,
         /// A 'requires'
         kRequires,
+        /// A 'return'
+        kReturn,
         /// A 'struct'
         kStruct,
         /// A 'switch'
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index 5c09c2a..23f82a2 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -1045,6 +1045,138 @@
 12:34 note: first attribute declared here)");
 }
 
+using SwitchStatementAttributeTest = TestWithParams;
+TEST_P(SwitchStatementAttributeTest, IsValid) {
+    auto& params = GetParam();
+
+    WrapInFunction(Switch(Expr(0_a), utils::Vector{DefaultCase()},
+                          createAttributes(Source{{12, 34}}, *this, params.kind)));
+
+    if (params.should_pass) {
+        EXPECT_TRUE(r()->Resolve()) << r()->error();
+    } else {
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for switch statements");
+    }
+}
+INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
+                         SwitchStatementAttributeTest,
+                         testing::Values(TestParams{AttributeKind::kAlign, false},
+                                         TestParams{AttributeKind::kBinding, false},
+                                         TestParams{AttributeKind::kBuiltin, false},
+                                         TestParams{AttributeKind::kDiagnostic, true},
+                                         TestParams{AttributeKind::kGroup, false},
+                                         TestParams{AttributeKind::kId, false},
+                                         TestParams{AttributeKind::kInterpolate, false},
+                                         TestParams{AttributeKind::kInvariant, false},
+                                         TestParams{AttributeKind::kLocation, false},
+                                         TestParams{AttributeKind::kMustUse, false},
+                                         TestParams{AttributeKind::kOffset, false},
+                                         TestParams{AttributeKind::kSize, false},
+                                         TestParams{AttributeKind::kStage, false},
+                                         TestParams{AttributeKind::kStride, false},
+                                         TestParams{AttributeKind::kWorkgroup, false},
+                                         TestParams{AttributeKind::kBindingAndGroup, false}));
+
+using IfStatementAttributeTest = TestWithParams;
+TEST_P(IfStatementAttributeTest, IsValid) {
+    auto& params = GetParam();
+
+    WrapInFunction(If(Expr(true), Block(), ElseStmt(),
+                      createAttributes(Source{{12, 34}}, *this, params.kind)));
+
+    if (params.should_pass) {
+        EXPECT_TRUE(r()->Resolve()) << r()->error();
+    } else {
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for if statements");
+    }
+}
+INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
+                         IfStatementAttributeTest,
+                         testing::Values(TestParams{AttributeKind::kAlign, false},
+                                         TestParams{AttributeKind::kBinding, false},
+                                         TestParams{AttributeKind::kBuiltin, false},
+                                         TestParams{AttributeKind::kDiagnostic, true},
+                                         TestParams{AttributeKind::kGroup, false},
+                                         TestParams{AttributeKind::kId, false},
+                                         TestParams{AttributeKind::kInterpolate, false},
+                                         TestParams{AttributeKind::kInvariant, false},
+                                         TestParams{AttributeKind::kLocation, false},
+                                         TestParams{AttributeKind::kMustUse, false},
+                                         TestParams{AttributeKind::kOffset, false},
+                                         TestParams{AttributeKind::kSize, false},
+                                         TestParams{AttributeKind::kStage, false},
+                                         TestParams{AttributeKind::kStride, false},
+                                         TestParams{AttributeKind::kWorkgroup, false},
+                                         TestParams{AttributeKind::kBindingAndGroup, false}));
+
+using ForStatementAttributeTest = TestWithParams;
+TEST_P(ForStatementAttributeTest, IsValid) {
+    auto& params = GetParam();
+
+    WrapInFunction(For(nullptr, Expr(false), nullptr, Block(),
+                       createAttributes(Source{{12, 34}}, *this, params.kind)));
+
+    if (params.should_pass) {
+        EXPECT_TRUE(r()->Resolve()) << r()->error();
+    } else {
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for for statements");
+    }
+}
+INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
+                         ForStatementAttributeTest,
+                         testing::Values(TestParams{AttributeKind::kAlign, false},
+                                         TestParams{AttributeKind::kBinding, false},
+                                         TestParams{AttributeKind::kBuiltin, false},
+                                         TestParams{AttributeKind::kDiagnostic, true},
+                                         TestParams{AttributeKind::kGroup, false},
+                                         TestParams{AttributeKind::kId, false},
+                                         TestParams{AttributeKind::kInterpolate, false},
+                                         TestParams{AttributeKind::kInvariant, false},
+                                         TestParams{AttributeKind::kLocation, false},
+                                         TestParams{AttributeKind::kMustUse, false},
+                                         TestParams{AttributeKind::kOffset, false},
+                                         TestParams{AttributeKind::kSize, false},
+                                         TestParams{AttributeKind::kStage, false},
+                                         TestParams{AttributeKind::kStride, false},
+                                         TestParams{AttributeKind::kWorkgroup, false},
+                                         TestParams{AttributeKind::kBindingAndGroup, false}));
+
+using WhileStatementAttributeTest = TestWithParams;
+TEST_P(WhileStatementAttributeTest, IsValid) {
+    auto& params = GetParam();
+
+    WrapInFunction(
+        While(Expr(false), Block(), createAttributes(Source{{12, 34}}, *this, params.kind)));
+
+    if (params.should_pass) {
+        EXPECT_TRUE(r()->Resolve()) << r()->error();
+    } else {
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for while statements");
+    }
+}
+INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
+                         WhileStatementAttributeTest,
+                         testing::Values(TestParams{AttributeKind::kAlign, false},
+                                         TestParams{AttributeKind::kBinding, false},
+                                         TestParams{AttributeKind::kBuiltin, false},
+                                         TestParams{AttributeKind::kDiagnostic, true},
+                                         TestParams{AttributeKind::kGroup, false},
+                                         TestParams{AttributeKind::kId, false},
+                                         TestParams{AttributeKind::kInterpolate, false},
+                                         TestParams{AttributeKind::kInvariant, false},
+                                         TestParams{AttributeKind::kLocation, false},
+                                         TestParams{AttributeKind::kMustUse, false},
+                                         TestParams{AttributeKind::kOffset, false},
+                                         TestParams{AttributeKind::kSize, false},
+                                         TestParams{AttributeKind::kStage, false},
+                                         TestParams{AttributeKind::kStride, false},
+                                         TestParams{AttributeKind::kWorkgroup, false},
+                                         TestParams{AttributeKind::kBindingAndGroup, false}));
+
 namespace BlockStatementTests {
 class BlockStatementTest : public TestWithParams {
   protected:
diff --git a/src/tint/resolver/builtin_test.cc b/src/tint/resolver/builtin_test.cc
index 2bc024f..80df98f 100644
--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -50,13 +50,11 @@
 
 using ExpressionList = utils::Vector<const ast::Expression*, 8>;
 
-using BuiltinType = sem::BuiltinType;
-
 using ResolverBuiltinTest = ResolverTest;
 
 struct BuiltinData {
     const char* name;
-    BuiltinType builtin;
+    builtin::Function builtin;
 };
 
 inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
@@ -253,7 +251,7 @@
 struct BuiltinDataWithParamNum {
     uint32_t args_number;
     const char* name;
-    BuiltinType builtin;
+    builtin::Function builtin;
 };
 
 inline std::ostream& operator<<(std::ostream& out, BuiltinDataWithParamNum data) {
@@ -680,55 +678,55 @@
 INSTANTIATE_TEST_SUITE_P(
     ResolverTest,
     ResolverBuiltinTest_FloatBuiltin_IdenticalType,
-    testing::Values(BuiltinDataWithParamNum{1, "abs", BuiltinType::kAbs},
-                    BuiltinDataWithParamNum{1, "acos", BuiltinType::kAcos},
-                    BuiltinDataWithParamNum{1, "acosh", BuiltinType::kAcos},
-                    BuiltinDataWithParamNum{1, "asin", BuiltinType::kAsin},
-                    BuiltinDataWithParamNum{1, "asinh", BuiltinType::kAsin},
-                    BuiltinDataWithParamNum{1, "atan", BuiltinType::kAtan},
-                    BuiltinDataWithParamNum{1, "atanh", BuiltinType::kAtan},
-                    BuiltinDataWithParamNum{2, "atan2", BuiltinType::kAtan2},
-                    BuiltinDataWithParamNum{1, "ceil", BuiltinType::kCeil},
-                    BuiltinDataWithParamNum{3, "clamp", BuiltinType::kClamp},
-                    BuiltinDataWithParamNum{1, "cos", BuiltinType::kCos},
-                    BuiltinDataWithParamNum{1, "cosh", BuiltinType::kCosh},
+    testing::Values(BuiltinDataWithParamNum{1, "abs", builtin::Function::kAbs},
+                    BuiltinDataWithParamNum{1, "acos", builtin::Function::kAcos},
+                    BuiltinDataWithParamNum{1, "acosh", builtin::Function::kAcos},
+                    BuiltinDataWithParamNum{1, "asin", builtin::Function::kAsin},
+                    BuiltinDataWithParamNum{1, "asinh", builtin::Function::kAsin},
+                    BuiltinDataWithParamNum{1, "atan", builtin::Function::kAtan},
+                    BuiltinDataWithParamNum{1, "atanh", builtin::Function::kAtan},
+                    BuiltinDataWithParamNum{2, "atan2", builtin::Function::kAtan2},
+                    BuiltinDataWithParamNum{1, "ceil", builtin::Function::kCeil},
+                    BuiltinDataWithParamNum{3, "clamp", builtin::Function::kClamp},
+                    BuiltinDataWithParamNum{1, "cos", builtin::Function::kCos},
+                    BuiltinDataWithParamNum{1, "cosh", builtin::Function::kCosh},
                     // cross: (vec3<T>, vec3<T>) -> vec3<T>
-                    BuiltinDataWithParamNum{1, "degrees", BuiltinType::kDegrees},
+                    BuiltinDataWithParamNum{1, "degrees", builtin::Function::kDegrees},
                     // distance: (T, T) -> T, (vecN<T>, vecN<T>) -> T
-                    BuiltinDataWithParamNum{1, "exp", BuiltinType::kExp},
-                    BuiltinDataWithParamNum{1, "exp2", BuiltinType::kExp2},
+                    BuiltinDataWithParamNum{1, "exp", builtin::Function::kExp},
+                    BuiltinDataWithParamNum{1, "exp2", builtin::Function::kExp2},
                     // faceForward: (vecN<T>, vecN<T>, vecN<T>) -> vecN<T>
-                    BuiltinDataWithParamNum{1, "floor", BuiltinType::kFloor},
-                    BuiltinDataWithParamNum{3, "fma", BuiltinType::kFma},
-                    BuiltinDataWithParamNum{1, "fract", BuiltinType::kFract},
+                    BuiltinDataWithParamNum{1, "floor", builtin::Function::kFloor},
+                    BuiltinDataWithParamNum{3, "fma", builtin::Function::kFma},
+                    BuiltinDataWithParamNum{1, "fract", builtin::Function::kFract},
                     // frexp
-                    BuiltinDataWithParamNum{1, "inverseSqrt", BuiltinType::kInverseSqrt},
+                    BuiltinDataWithParamNum{1, "inverseSqrt", builtin::Function::kInverseSqrt},
                     // ldexp: (T, i32) -> T, (vecN<T>, vecN<i32>) -> vecN<T>
                     // length: (vecN<T>) -> T
-                    BuiltinDataWithParamNum{1, "log", BuiltinType::kLog},
-                    BuiltinDataWithParamNum{1, "log2", BuiltinType::kLog2},
-                    BuiltinDataWithParamNum{2, "max", BuiltinType::kMax},
-                    BuiltinDataWithParamNum{2, "min", BuiltinType::kMin},
+                    BuiltinDataWithParamNum{1, "log", builtin::Function::kLog},
+                    BuiltinDataWithParamNum{1, "log2", builtin::Function::kLog2},
+                    BuiltinDataWithParamNum{2, "max", builtin::Function::kMax},
+                    BuiltinDataWithParamNum{2, "min", builtin::Function::kMin},
                     // Note that `mix(vecN<f32>, vecN<f32>, f32) -> vecN<f32>` is not tested here.
-                    BuiltinDataWithParamNum{3, "mix", BuiltinType::kMix},
+                    BuiltinDataWithParamNum{3, "mix", builtin::Function::kMix},
                     // modf
                     // normalize: (vecN<T>) -> vecN<T>
-                    BuiltinDataWithParamNum{2, "pow", BuiltinType::kPow},
+                    BuiltinDataWithParamNum{2, "pow", builtin::Function::kPow},
                     // quantizeToF16 is not implemented yet.
-                    BuiltinDataWithParamNum{1, "radians", BuiltinType::kRadians},
+                    BuiltinDataWithParamNum{1, "radians", builtin::Function::kRadians},
                     // reflect: (vecN<T>, vecN<T>) -> vecN<T>
                     // refract: (vecN<T>, vecN<T>, T) -> vecN<T>
-                    BuiltinDataWithParamNum{1, "round", BuiltinType::kRound},
+                    BuiltinDataWithParamNum{1, "round", builtin::Function::kRound},
                     // saturate not implemented yet.
-                    BuiltinDataWithParamNum{1, "sign", BuiltinType::kSign},
-                    BuiltinDataWithParamNum{1, "sin", BuiltinType::kSin},
-                    BuiltinDataWithParamNum{1, "sinh", BuiltinType::kSinh},
-                    BuiltinDataWithParamNum{3, "smoothstep", BuiltinType::kSmoothstep},
-                    BuiltinDataWithParamNum{1, "sqrt", BuiltinType::kSqrt},
-                    BuiltinDataWithParamNum{2, "step", BuiltinType::kStep},
-                    BuiltinDataWithParamNum{1, "tan", BuiltinType::kTan},
-                    BuiltinDataWithParamNum{1, "tanh", BuiltinType::kTanh},
-                    BuiltinDataWithParamNum{1, "trunc", BuiltinType::kTrunc}));
+                    BuiltinDataWithParamNum{1, "sign", builtin::Function::kSign},
+                    BuiltinDataWithParamNum{1, "sin", builtin::Function::kSin},
+                    BuiltinDataWithParamNum{1, "sinh", builtin::Function::kSinh},
+                    BuiltinDataWithParamNum{3, "smoothstep", builtin::Function::kSmoothstep},
+                    BuiltinDataWithParamNum{1, "sqrt", builtin::Function::kSqrt},
+                    BuiltinDataWithParamNum{2, "step", builtin::Function::kStep},
+                    BuiltinDataWithParamNum{1, "tan", builtin::Function::kTan},
+                    BuiltinDataWithParamNum{1, "tanh", builtin::Function::kTanh},
+                    BuiltinDataWithParamNum{1, "trunc", builtin::Function::kTrunc}));
 
 using ResolverBuiltinFloatTest = ResolverTest;
 
@@ -1409,7 +1407,7 @@
 struct BuiltinDataWithParamNum {
     uint32_t args_number;
     const char* name;
-    BuiltinType builtin;
+    builtin::Function builtin;
 };
 
 inline std::ostream& operator<<(std::ostream& out, BuiltinDataWithParamNum data) {
@@ -1805,18 +1803,18 @@
     ResolverTest,
     ResolverBuiltinTest_IntegerBuiltin_IdenticalType,
     testing::Values(
-        BuiltinDataWithParamNum{1, "abs", BuiltinType::kAbs},
-        BuiltinDataWithParamNum{3, "clamp", BuiltinType::kClamp},
-        BuiltinDataWithParamNum{1, "countLeadingZeros", BuiltinType::kCountLeadingZeros},
-        BuiltinDataWithParamNum{1, "countOneBits", BuiltinType::kCountOneBits},
-        BuiltinDataWithParamNum{1, "countTrailingZeros", BuiltinType::kCountTrailingZeros},
+        BuiltinDataWithParamNum{1, "abs", builtin::Function::kAbs},
+        BuiltinDataWithParamNum{3, "clamp", builtin::Function::kClamp},
+        BuiltinDataWithParamNum{1, "countLeadingZeros", builtin::Function::kCountLeadingZeros},
+        BuiltinDataWithParamNum{1, "countOneBits", builtin::Function::kCountOneBits},
+        BuiltinDataWithParamNum{1, "countTrailingZeros", builtin::Function::kCountTrailingZeros},
         // extractBits: (T, u32, u32) -> T
-        BuiltinDataWithParamNum{1, "firstLeadingBit", BuiltinType::kFirstLeadingBit},
-        BuiltinDataWithParamNum{1, "firstTrailingBit", BuiltinType::kFirstTrailingBit},
+        BuiltinDataWithParamNum{1, "firstLeadingBit", builtin::Function::kFirstLeadingBit},
+        BuiltinDataWithParamNum{1, "firstTrailingBit", builtin::Function::kFirstTrailingBit},
         // insertBits: (T, T, u32, u32) -> T
-        BuiltinDataWithParamNum{2, "max", BuiltinType::kMax},
-        BuiltinDataWithParamNum{2, "min", BuiltinType::kMin},
-        BuiltinDataWithParamNum{1, "reverseBits", BuiltinType::kReverseBits}));
+        BuiltinDataWithParamNum{2, "max", builtin::Function::kMax},
+        BuiltinDataWithParamNum{2, "min", builtin::Function::kMin},
+        BuiltinDataWithParamNum{1, "reverseBits", builtin::Function::kReverseBits}));
 
 }  // namespace integer_builtin_tests
 
@@ -2263,7 +2261,9 @@
         case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
             return R"(textureGatherCompare(texture, sampler, coords, array_index, depth_ref))";
         case ValidTextureOverload::kNumLayers2dArray:
+        case ValidTextureOverload::kNumLayersCubeArray:
         case ValidTextureOverload::kNumLayersDepth2dArray:
+        case ValidTextureOverload::kNumLayersDepthCubeArray:
         case ValidTextureOverload::kNumLayersStorageWO2dArray:
             return R"(textureNumLayers(texture))";
         case ValidTextureOverload::kNumLevels2d:
@@ -2553,8 +2553,8 @@
 TEST_P(ResolverBuiltinTest_DataPacking, InferType) {
     auto param = GetParam();
 
-    bool pack4 =
-        param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+    bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+                 param.builtin == builtin::Function::kPack4X8Unorm;
 
     auto* call = pack4 ? Call(param.name, vec4<f32>(1_f, 2_f, 3_f, 4_f))
                        : Call(param.name, vec2<f32>(1_f, 2_f));
@@ -2568,8 +2568,8 @@
 TEST_P(ResolverBuiltinTest_DataPacking, Error_IncorrectParamType) {
     auto param = GetParam();
 
-    bool pack4 =
-        param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+    bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+                 param.builtin == builtin::Function::kPack4X8Unorm;
 
     auto* call = pack4 ? Call(param.name, vec4<i32>(1_i, 2_i, 3_i, 4_i))
                        : Call(param.name, vec2<i32>(1_i, 2_i));
@@ -2594,8 +2594,8 @@
 TEST_P(ResolverBuiltinTest_DataPacking, Error_TooManyParams) {
     auto param = GetParam();
 
-    bool pack4 =
-        param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+    bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+                 param.builtin == builtin::Function::kPack4X8Unorm;
 
     auto* call = pack4 ? Call(param.name, vec4<f32>(1_f, 2_f, 3_f, 4_f), 1_f)
                        : Call(param.name, vec2<f32>(1_f, 2_f), 1_f);
@@ -2606,14 +2606,14 @@
     EXPECT_THAT(r()->error(), HasSubstr("error: no matching call to " + std::string(param.name)));
 }
 
-INSTANTIATE_TEST_SUITE_P(ResolverTest,
-                         ResolverBuiltinTest_DataPacking,
-                         testing::Values(BuiltinData{"pack4x8snorm", BuiltinType::kPack4X8Snorm},
-                                         BuiltinData{"pack4x8unorm", BuiltinType::kPack4X8Unorm},
-                                         BuiltinData{"pack2x16snorm", BuiltinType::kPack2X16Snorm},
-                                         BuiltinData{"pack2x16unorm", BuiltinType::kPack2X16Unorm},
-                                         BuiltinData{"pack2x16float",
-                                                     BuiltinType::kPack2X16Float}));
+INSTANTIATE_TEST_SUITE_P(
+    ResolverTest,
+    ResolverBuiltinTest_DataPacking,
+    testing::Values(BuiltinData{"pack4x8snorm", builtin::Function::kPack4X8Snorm},
+                    BuiltinData{"pack4x8unorm", builtin::Function::kPack4X8Unorm},
+                    BuiltinData{"pack2x16snorm", builtin::Function::kPack2X16Snorm},
+                    BuiltinData{"pack2x16unorm", builtin::Function::kPack2X16Unorm},
+                    BuiltinData{"pack2x16float", builtin::Function::kPack2X16Float}));
 
 }  // namespace data_packing_builtin_tests
 
@@ -2624,8 +2624,8 @@
 TEST_P(ResolverBuiltinTest_DataUnpacking, InferType) {
     auto param = GetParam();
 
-    bool pack4 = param.builtin == BuiltinType::kUnpack4X8Snorm ||
-                 param.builtin == BuiltinType::kUnpack4X8Unorm;
+    bool pack4 = param.builtin == builtin::Function::kUnpack4X8Snorm ||
+                 param.builtin == builtin::Function::kUnpack4X8Unorm;
 
     auto* call = Call(param.name, 1_u);
     WrapInFunction(call);
@@ -2643,11 +2643,11 @@
 INSTANTIATE_TEST_SUITE_P(
     ResolverTest,
     ResolverBuiltinTest_DataUnpacking,
-    testing::Values(BuiltinData{"unpack4x8snorm", BuiltinType::kUnpack4X8Snorm},
-                    BuiltinData{"unpack4x8unorm", BuiltinType::kUnpack4X8Unorm},
-                    BuiltinData{"unpack2x16snorm", BuiltinType::kUnpack2X16Snorm},
-                    BuiltinData{"unpack2x16unorm", BuiltinType::kUnpack2X16Unorm},
-                    BuiltinData{"unpack2x16float", BuiltinType::kUnpack2X16Float}));
+    testing::Values(BuiltinData{"unpack4x8snorm", builtin::Function::kUnpack4X8Snorm},
+                    BuiltinData{"unpack4x8unorm", builtin::Function::kUnpack4X8Unorm},
+                    BuiltinData{"unpack2x16snorm", builtin::Function::kUnpack2X16Snorm},
+                    BuiltinData{"unpack2x16unorm", builtin::Function::kUnpack2X16Unorm},
+                    BuiltinData{"unpack2x16float", builtin::Function::kUnpack2X16Float}));
 
 }  // namespace data_unpacking_builtin_tests
 
@@ -2680,8 +2680,8 @@
 INSTANTIATE_TEST_SUITE_P(
     ResolverTest,
     ResolverBuiltinTest_Barrier,
-    testing::Values(BuiltinData{"storageBarrier", BuiltinType::kStorageBarrier},
-                    BuiltinData{"workgroupBarrier", BuiltinType::kWorkgroupBarrier}));
+    testing::Values(BuiltinData{"storageBarrier", builtin::Function::kStorageBarrier},
+                    BuiltinData{"workgroupBarrier", builtin::Function::kWorkgroupBarrier}));
 
 }  // namespace synchronization_builtin_tests
 
diff --git a/src/tint/resolver/call_validation_test.cc b/src/tint/resolver/call_validation_test.cc
index b749df9..b00db68 100644
--- a/src/tint/resolver/call_validation_test.cc
+++ b/src/tint/resolver/call_validation_test.cc
@@ -478,5 +478,34 @@
     EXPECT_EQ(r()->error(), "12:34 error: ignoring return value of builtin 'max'");
 }
 
+TEST_F(ResolverCallValidationTest, UnexpectedFunctionTemplateArgs) {
+    // fn a() {}
+    // fn b() {
+    //   a<i32>();
+    // }
+    Func(Source{{56, 78}}, "a", utils::Empty, ty.void_(), utils::Empty);
+    Func("b", utils::Empty, ty.void_(),
+         utils::Vector{
+             CallStmt(Call(Ident(Source{{12, 34}}, "a", "i32"))),
+         });
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: function 'a' does not take template arguments
+56:78 note: function 'a' declared here)");
+}
+
+TEST_F(ResolverCallValidationTest, UnexpectedBuiltinTemplateArgs) {
+    // fn f() {
+    //   min<i32>(1, 2);
+    // }
+    Func("f", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Var("v", Call(Ident(Source{{12, 34}}, "min", "i32"), 1_a, 2_a))),
+         });
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: builtin 'min' does not take template arguments)");
+}
+
 }  // namespace
 }  // namespace tint::resolver
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 325ccb0..b90ea00 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -30,6 +30,7 @@
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/member_accessor_expression.h"
 #include "src/tint/sem/value_constructor.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/abstract_float.h"
 #include "src/tint/type/abstract_int.h"
 #include "src/tint/type/array.h"
@@ -325,35 +326,20 @@
                                   const Source& source,
                                   bool use_runtime_semantics);
 
-ConstEval::Result SplatConvert(const constant::Splat* splat,
-                               ProgramBuilder& builder,
-                               const type::Type* target_ty,
-                               const Source& source,
-                               bool use_runtime_semantics) {
-    // Convert the single splatted element type.
-    auto conv_el = ConvertInternal(splat->el, builder, type::Type::ElementOf(target_ty), source,
-                                   use_runtime_semantics);
-    if (!conv_el) {
-        return utils::Failure;
-    }
-    if (!conv_el.Get()) {
-        return nullptr;
-    }
-    return builder.create<constant::Splat>(target_ty, conv_el.Get(), splat->count);
-}
-
-ConstEval::Result CompositeConvert(const constant::Composite* composite,
+ConstEval::Result CompositeConvert(const constant::Value* value,
                                    ProgramBuilder& builder,
                                    const type::Type* target_ty,
                                    const Source& source,
                                    bool use_runtime_semantics) {
+    const size_t el_count = value->NumElements();
+
     // Convert each of the composite element types.
     utils::Vector<const constant::Value*, 4> conv_els;
-    conv_els.Reserve(composite->elements.Length());
+    conv_els.Reserve(el_count);
 
     std::function<const type::Type*(size_t idx)> target_el_ty;
     if (auto* str = target_ty->As<type::Struct>()) {
-        if (TINT_UNLIKELY(str->Members().Length() != composite->elements.Length())) {
+        if (TINT_UNLIKELY(str->Members().Length() != el_count)) {
             TINT_ICE(Resolver, builder.Diagnostics())
                 << "const-eval conversion of structure has mismatched element counts";
             return utils::Failure;
@@ -364,7 +350,8 @@
         target_el_ty = [el_ty](size_t) { return el_ty; };
     }
 
-    for (auto* el : composite->elements) {
+    for (size_t i = 0; i < el_count; i++) {
+        auto* el = value->Index(i);
         auto conv_el = ConvertInternal(el, builder, target_el_ty(conv_els.Length()), source,
                                        use_runtime_semantics);
         if (!conv_el) {
@@ -378,6 +365,40 @@
     return builder.create<constant::Composite>(target_ty, std::move(conv_els));
 }
 
+ConstEval::Result SplatConvert(const constant::Splat* splat,
+                               ProgramBuilder& builder,
+                               const type::Type* target_ty,
+                               const Source& source,
+                               bool use_runtime_semantics) {
+    const type::Type* target_el_ty = nullptr;
+    if (auto* str = target_ty->As<type::Struct>()) {
+        // Structure conversion.
+        auto members = str->Members();
+        target_el_ty = members[0]->Type();
+
+        // Structures can only be converted during materialization. The user cannot declare the
+        // target structure type, so each member type must be the same default materialization type.
+        for (size_t i = 1; i < members.Length(); i++) {
+            if (members[i]->Type() != target_el_ty) {
+                TINT_ICE(Resolver, builder.Diagnostics())
+                    << "inconsistent target struct member types for SplatConvert";
+                return utils::Failure;
+            }
+        }
+    } else {
+        target_el_ty = type::Type::ElementOf(target_ty);
+    }
+    // Convert the single splatted element type.
+    auto conv_el = ConvertInternal(splat->el, builder, target_el_ty, source, use_runtime_semantics);
+    if (!conv_el) {
+        return utils::Failure;
+    }
+    if (!conv_el.Get()) {
+        return nullptr;
+    }
+    return builder.create<constant::Splat>(target_ty, conv_el.Get(), splat->count);
+}
+
 ConstEval::Result ConvertInternal(const constant::Value* c,
                                   ProgramBuilder& builder,
                                   const type::Type* target_ty,
diff --git a/src/tint/resolver/const_eval_builtin_test.cc b/src/tint/resolver/const_eval_builtin_test.cc
index bd32779..2cef1d1 100644
--- a/src/tint/resolver/const_eval_builtin_test.cc
+++ b/src/tint/resolver/const_eval_builtin_test.cc
@@ -139,7 +139,7 @@
     return Case{std::move(args), std::move(err)};
 }
 
-using ResolverConstEvalBuiltinTest = ResolverTestWithParam<std::tuple<sem::BuiltinType, Case>>;
+using ResolverConstEvalBuiltinTest = ResolverTestWithParam<std::tuple<builtin::Function, Case>>;
 
 TEST_P(ResolverConstEvalBuiltinTest, Test) {
     Enable(builtin::Extension::kF16);
@@ -152,7 +152,7 @@
         args.Push(a.Expr(*this));
     }
 
-    auto* expr = Call(Source{{12, 34}}, sem::str(builtin), std::move(args));
+    auto* expr = Call(Source{{12, 34}}, builtin::str(builtin), std::move(args));
     GlobalConst("C", expr);
 
     if (c.expected) {
@@ -187,7 +187,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     MixedAbstractArgs,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAtan2),
+    testing::Combine(testing::Values(builtin::Function::kAtan2),
                      testing::ValuesIn(std::vector{
                          C({0_a, -0.0_a}, kPi<AFloat>),
                          C({1.0_a, 0_a}, kPiOver2<AFloat>),
@@ -222,7 +222,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Abs,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAbs),
+    testing::Combine(testing::Values(builtin::Function::kAbs),
                      testing::ValuesIn(Concat(AbsCases<AInt>(),  //
                                               AbsCases<i32>(),
                                               AbsCases<u32>(),
@@ -257,7 +257,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     All,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAll), testing::ValuesIn(AllCases())));
+    testing::Combine(testing::Values(builtin::Function::kAll), testing::ValuesIn(AllCases())));
 
 static std::vector<Case> AnyCases() {
     return {
@@ -286,7 +286,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Any,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAny), testing::ValuesIn(AnyCases())));
+    testing::Combine(testing::Values(builtin::Function::kAny), testing::ValuesIn(AnyCases())));
 
 template <typename T>
 std::vector<Case> Atan2Cases() {
@@ -315,7 +315,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Atan2,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAtan2),
+    testing::Combine(testing::Values(builtin::Function::kAtan2),
                      testing::ValuesIn(Concat(Atan2Cases<AFloat>(),  //
                                               Atan2Cases<f32>(),
                                               Atan2Cases<f16>()))));
@@ -336,7 +336,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Atan,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAtan),
+    testing::Combine(testing::Values(builtin::Function::kAtan),
                      testing::ValuesIn(Concat(AtanCases<AFloat>(),  //
                                               AtanCases<f32>(),
                                               AtanCases<f16>()))));
@@ -361,7 +361,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Atanh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAtanh),
+    testing::Combine(testing::Values(builtin::Function::kAtanh),
                      testing::ValuesIn(Concat(AtanhCases<AFloat>(),  //
                                               AtanhCases<f32>(),
                                               AtanhCases<f16>()))));
@@ -387,7 +387,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Acos,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAcos),
+    testing::Combine(testing::Values(builtin::Function::kAcos),
                      testing::ValuesIn(Concat(AcosCases<AFloat>(),  //
                                               AcosCases<f32>(),
                                               AcosCases<f16>()))));
@@ -409,7 +409,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Acosh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAcosh),
+    testing::Combine(testing::Values(builtin::Function::kAcosh),
                      testing::ValuesIn(Concat(AcoshCases<AFloat>(),  //
                                               AcoshCases<f32>(),
                                               AcoshCases<f16>()))));
@@ -436,7 +436,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Asin,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAsin),
+    testing::Combine(testing::Values(builtin::Function::kAsin),
                      testing::ValuesIn(Concat(AsinCases<AFloat>(),  //
                                               AsinCases<f32>(),
                                               AsinCases<f16>()))));
@@ -460,7 +460,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Asinh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kAsinh),
+    testing::Combine(testing::Values(builtin::Function::kAsinh),
                      testing::ValuesIn(Concat(AsinhCases<AFloat>(),  //
                                               AsinhCases<f32>(),
                                               AsinhCases<f16>()))));
@@ -482,7 +482,7 @@
     Ceil,
     ResolverConstEvalBuiltinTest,
     testing::Combine(
-        testing::Values(sem::BuiltinType::kCeil),
+        testing::Values(builtin::Function::kCeil),
         testing::ValuesIn(Concat(CeilCases<AFloat>(), CeilCases<f32>(), CeilCases<f16>()))));
 
 template <typename T>
@@ -512,7 +512,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Clamp,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kClamp),
+    testing::Combine(testing::Values(builtin::Function::kClamp),
                      testing::ValuesIn(Concat(ClampCases<AInt>(),  //
                                               ClampCases<i32>(),
                                               ClampCases<u32>(),
@@ -535,7 +535,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Cos,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCos),
+    testing::Combine(testing::Values(builtin::Function::kCos),
                      testing::ValuesIn(Concat(CosCases<AFloat>(),  //
                                               CosCases<f32>(),
                                               CosCases<f16>()))));
@@ -561,7 +561,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Cosh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCosh),
+    testing::Combine(testing::Values(builtin::Function::kCosh),
                      testing::ValuesIn(Concat(CoshCases<AFloat>(),  //
                                               CoshCases<f32>(),
                                               CoshCases<f16>()))));
@@ -608,7 +608,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     CountLeadingZeros,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCountLeadingZeros),
+    testing::Combine(testing::Values(builtin::Function::kCountLeadingZeros),
                      testing::ValuesIn(Concat(CountLeadingZerosCases<i32>(),  //
                                               CountLeadingZerosCases<u32>()))));
 
@@ -654,7 +654,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     CountTrailingZeros,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCountTrailingZeros),
+    testing::Combine(testing::Values(builtin::Function::kCountTrailingZeros),
                      testing::ValuesIn(Concat(CountTrailingZerosCases<i32>(),  //
                                               CountTrailingZerosCases<u32>()))));
 
@@ -691,7 +691,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     CountOneBits,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCountOneBits),
+    testing::Combine(testing::Values(builtin::Function::kCountOneBits),
                      testing::ValuesIn(Concat(CountOneBitsCases<i32>(),  //
                                               CountOneBitsCases<u32>()))));
 
@@ -790,7 +790,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Cross,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kCross),
+    testing::Combine(testing::Values(builtin::Function::kCross),
                      testing::ValuesIn(Concat(CrossCases<AFloat>(),  //
                                               CrossCases<f32>(),     //
                                               CrossCases<f16>()))));
@@ -817,7 +817,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Distance,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDistance),
+    testing::Combine(testing::Values(builtin::Function::kDistance),
                      testing::ValuesIn(Concat(DistanceCases<AFloat>(),  //
                                               DistanceCases<f32>(),     //
                                               DistanceCases<f16>()))));
@@ -865,7 +865,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Dot,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDot),
+    testing::Combine(testing::Values(builtin::Function::kDot),
                      testing::ValuesIn(Concat(DotCases<AInt>(),    //
                                               DotCases<i32>(),     //
                                               DotCases<u32>(),     //
@@ -945,7 +945,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Determinant,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDeterminant),
+    testing::Combine(testing::Values(builtin::Function::kDeterminant),
                      testing::ValuesIn(Concat(DeterminantCases<AFloat>(),  //
                                               DeterminantCases<f32>(),     //
                                               DeterminantCases<f16>()))));
@@ -1027,7 +1027,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     FaceForward,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFaceForward),
+    testing::Combine(testing::Values(builtin::Function::kFaceForward),
                      testing::ValuesIn(Concat(FaceForwardCases<AFloat>(),  //
                                               FaceForwardCases<f32>(),     //
                                               FaceForwardCases<f16>()))));
@@ -1090,7 +1090,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     FirstLeadingBit,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFirstLeadingBit),
+    testing::Combine(testing::Values(builtin::Function::kFirstLeadingBit),
                      testing::ValuesIn(Concat(FirstLeadingBitCases<i32>(),  //
                                               FirstLeadingBitCases<u32>()))));
 
@@ -1123,7 +1123,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     FirstTrailingBit,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFirstTrailingBit),
+    testing::Combine(testing::Values(builtin::Function::kFirstTrailingBit),
                      testing::ValuesIn(Concat(FirstTrailingBitCases<i32>(),  //
                                               FirstTrailingBitCases<u32>()))));
 
@@ -1143,7 +1143,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Floor,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFloor),
+    testing::Combine(testing::Values(builtin::Function::kFloor),
                      testing::ValuesIn(Concat(FloorCases<AFloat>(),  //
                                               FloorCases<f32>(),
                                               FloorCases<f16>()))));
@@ -1167,7 +1167,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Fma,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFma),
+    testing::Combine(testing::Values(builtin::Function::kFma),
                      testing::ValuesIn(Concat(FmaCases<AFloat>(),  //
                                               FmaCases<f32>(),
                                               FmaCases<f16>()))));
@@ -1199,7 +1199,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Fract,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFract),
+    testing::Combine(testing::Values(builtin::Function::kFract),
                      testing::ValuesIn(Concat(FractCases<AFloat>(),  //
                                               FractCases<f32>(),
                                               FractCases<f16>()))));
@@ -1256,7 +1256,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Frexp,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kFrexp),
+    testing::Combine(testing::Values(builtin::Function::kFrexp),
                      testing::ValuesIn(Concat(FrexpCases<AFloat>(),  //
                                               FrexpCases<f32>(),     //
                                               FrexpCases<f16>()))));
@@ -1338,7 +1338,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     InsertBits,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kInsertBits),
+    testing::Combine(testing::Values(builtin::Function::kInsertBits),
                      testing::ValuesIn(Concat(InsertBitsCases<i32>(),  //
                                               InsertBitsCases<u32>()))));
 
@@ -1358,7 +1358,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     InverseSqrt,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kInverseSqrt),
+    testing::Combine(testing::Values(builtin::Function::kInverseSqrt),
                      testing::ValuesIn(Concat(InverseSqrtCases<AFloat>(),  //
                                               InverseSqrtCases<f32>(),
                                               InverseSqrtCases<f16>()))));
@@ -1377,7 +1377,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     DegreesAFloat,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+    testing::Combine(testing::Values(builtin::Function::kDegrees),
                      testing::ValuesIn(DegreesAFloatCases<AFloat>())));
 
 template <typename T>
@@ -1394,7 +1394,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     DegreesF32,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+    testing::Combine(testing::Values(builtin::Function::kDegrees),
                      testing::ValuesIn(DegreesF32Cases<f32>())));
 
 template <typename T>
@@ -1411,7 +1411,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     DegreesF16,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+    testing::Combine(testing::Values(builtin::Function::kDegrees),
                      testing::ValuesIn(DegreesF16Cases<f16>())));
 
 template <typename T>
@@ -1428,7 +1428,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Exp,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kExp),
+    testing::Combine(testing::Values(builtin::Function::kExp),
                      testing::ValuesIn(Concat(ExpCases<AFloat>(),  //
                                               ExpCases<f32>(),
                                               ExpCases<f16>()))));
@@ -1449,7 +1449,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Exp2,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kExp2),
+    testing::Combine(testing::Values(builtin::Function::kExp2),
                      testing::ValuesIn(Concat(Exp2Cases<AFloat>(),  //
                                               Exp2Cases<f32>(),
                                               Exp2Cases<f16>()))));
@@ -1546,7 +1546,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     ExtractBits,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kExtractBits),
+    testing::Combine(testing::Values(builtin::Function::kExtractBits),
                      testing::ValuesIn(Concat(ExtractBitsCases<i32>(),  //
                                               ExtractBitsCases<u32>()))));
 
@@ -1610,7 +1610,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Ldexp,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLdexp),
+    testing::Combine(testing::Values(builtin::Function::kLdexp),
                      testing::ValuesIn(Concat(LdexpCases<AFloat>(),  //
                                               LdexpCases<f32>(),
                                               LdexpCases<f16>()))));
@@ -1669,7 +1669,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Length,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLength),
+    testing::Combine(testing::Values(builtin::Function::kLength),
                      testing::ValuesIn(Concat(LengthCases<AFloat>(),  //
                                               LengthCases<f32>(),
                                               LengthCases<f16>()))));
@@ -1685,7 +1685,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Log,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog),
+    testing::Combine(testing::Values(builtin::Function::kLog),
                      testing::ValuesIn(Concat(LogCases<AFloat>(),  //
                                               LogCases<f32>(),
                                               LogCases<f16>()))));
@@ -1698,7 +1698,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     LogF16,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog),
+    testing::Combine(testing::Values(builtin::Function::kLog),
                      testing::ValuesIn(LogF16Cases<f16>())));
 template <typename T>
 std::vector<Case> LogF32Cases() {
@@ -1709,7 +1709,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     LogF32,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog),
+    testing::Combine(testing::Values(builtin::Function::kLog),
                      testing::ValuesIn(LogF32Cases<f32>())));
 
 template <typename T>
@@ -1721,7 +1721,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     LogAbstract,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog),
+    testing::Combine(testing::Values(builtin::Function::kLog),
                      testing::ValuesIn(LogAbstractCases<AFloat>())));
 
 template <typename T>
@@ -1739,7 +1739,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Log2,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+    testing::Combine(testing::Values(builtin::Function::kLog2),
                      testing::ValuesIn(Concat(Log2Cases<AFloat>(),  //
                                               Log2Cases<f32>(),
                                               Log2Cases<f16>()))));
@@ -1752,7 +1752,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Log2F16,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+    testing::Combine(testing::Values(builtin::Function::kLog2),
                      testing::ValuesIn(Log2F16Cases<f16>())));
 template <typename T>
 std::vector<Case> Log2F32Cases() {
@@ -1763,7 +1763,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Log2F32,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+    testing::Combine(testing::Values(builtin::Function::kLog2),
                      testing::ValuesIn(Log2F32Cases<f32>())));
 template <typename T>
 std::vector<Case> Log2AbstractCases() {
@@ -1774,7 +1774,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Log2Abstract,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+    testing::Combine(testing::Values(builtin::Function::kLog2),
                      testing::ValuesIn(Log2AbstractCases<AFloat>())));
 
 template <typename T>
@@ -1797,7 +1797,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Max,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kMax),
+    testing::Combine(testing::Values(builtin::Function::kMax),
                      testing::ValuesIn(Concat(MaxCases<AInt>(),  //
                                               MaxCases<i32>(),
                                               MaxCases<u32>(),
@@ -1823,7 +1823,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Min,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kMin),
+    testing::Combine(testing::Values(builtin::Function::kMin),
                      testing::ValuesIn(Concat(MinCases<AInt>(),  //
                                               MinCases<i32>(),
                                               MinCases<u32>(),
@@ -1913,7 +1913,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Mix,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kMix),
+    testing::Combine(testing::Values(builtin::Function::kMix),
                      testing::ValuesIn(Concat(MixCases<AFloat>(),  //
                                               MixCases<f32>(),     //
                                               MixCases<f16>()))));
@@ -1947,7 +1947,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Modf,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kModf),
+    testing::Combine(testing::Values(builtin::Function::kModf),
                      testing::ValuesIn(Concat(ModfCases<AFloat>(),  //
                                               ModfCases<f32>(),     //
                                               ModfCases<f16>()))));
@@ -1977,7 +1977,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Normalize,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kNormalize),
+    testing::Combine(testing::Values(builtin::Function::kNormalize),
                      testing::ValuesIn(Concat(NormalizeCases<AFloat>(),  //
                                               NormalizeCases<f32>(),     //
                                               NormalizeCases<f16>()))));
@@ -1997,7 +1997,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pack4x8snorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPack4X8Snorm),
+    testing::Combine(testing::Values(builtin::Function::kPack4X8Snorm),
                      testing::ValuesIn(Pack4x8snormCases())));
 
 std::vector<Case> Pack4x8unormCases() {
@@ -2014,7 +2014,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pack4x8unorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPack4X8Unorm),
+    testing::Combine(testing::Values(builtin::Function::kPack4X8Unorm),
                      testing::ValuesIn(Pack4x8unormCases())));
 
 std::vector<Case> Pack2x16floatCases() {
@@ -2035,7 +2035,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pack2x16float,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Float),
+    testing::Combine(testing::Values(builtin::Function::kPack2X16Float),
                      testing::ValuesIn(Pack2x16floatCases())));
 
 std::vector<Case> Pack2x16snormCases() {
@@ -2053,7 +2053,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pack2x16snorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Snorm),
+    testing::Combine(testing::Values(builtin::Function::kPack2X16Snorm),
                      testing::ValuesIn(Pack2x16snormCases())));
 
 std::vector<Case> Pack2x16unormCases() {
@@ -2067,7 +2067,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pack2x16unorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Unorm),
+    testing::Combine(testing::Values(builtin::Function::kPack2X16Unorm),
                      testing::ValuesIn(Pack2x16unormCases())));
 
 template <typename T>
@@ -2113,7 +2113,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Pow,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kPow),
+    testing::Combine(testing::Values(builtin::Function::kPow),
                      testing::ValuesIn(Concat(PowCases<AFloat>(),  //
                                               PowCases<f32>(),     //
                                               PowCases<f16>()))));
@@ -2160,7 +2160,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     ReverseBits,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kReverseBits),
+    testing::Combine(testing::Values(builtin::Function::kReverseBits),
                      testing::ValuesIn(Concat(ReverseBitsCases<i32>(),  //
                                               ReverseBitsCases<u32>()))));
 
@@ -2212,7 +2212,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Reflect,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kReflect),
+    testing::Combine(testing::Values(builtin::Function::kReflect),
                      testing::ValuesIn(Concat(ReflectCases<AFloat>(),  //
                                               ReflectCases<f32>(),     //
                                               ReflectCases<f16>()))));
@@ -2294,7 +2294,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Refract,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kRefract),
+    testing::Combine(testing::Values(builtin::Function::kRefract),
                      testing::ValuesIn(Concat(RefractCases<AFloat>(),  //
                                               RefractCases<f32>(),     //
                                               RefractCases<f16>()))));
@@ -2313,7 +2313,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Radians,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kRadians),
+    testing::Combine(testing::Values(builtin::Function::kRadians),
                      testing::ValuesIn(Concat(RadiansCases<AFloat>(),  //
                                               RadiansCases<f32>()))));
 
@@ -2331,7 +2331,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     RadiansF16,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kRadians),
+    testing::Combine(testing::Values(builtin::Function::kRadians),
                      testing::ValuesIn(RadiansF16Cases<f16>())));
 
 template <typename T>
@@ -2357,7 +2357,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Round,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kRound),
+    testing::Combine(testing::Values(builtin::Function::kRound),
                      testing::ValuesIn(Concat(RoundCases<AFloat>(),  //
                                               RoundCases<f32>(),
                                               RoundCases<f16>()))));
@@ -2382,7 +2382,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Saturate,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSaturate),
+    testing::Combine(testing::Values(builtin::Function::kSaturate),
                      testing::ValuesIn(Concat(SaturateCases<AFloat>(),  //
                                               SaturateCases<f32>(),
                                               SaturateCases<f16>()))));
@@ -2424,7 +2424,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Select,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSelect),
+    testing::Combine(testing::Values(builtin::Function::kSelect),
                      testing::ValuesIn(Concat(SelectCases<AInt>(),  //
                                               SelectCases<i32>(),
                                               SelectCases<u32>(),
@@ -2465,7 +2465,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Sign,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSign),
+    testing::Combine(testing::Values(builtin::Function::kSign),
                      testing::ValuesIn(Concat(SignCases<AInt>(),  //
                                               SignCases<i32>(),
                                               SignCases<AFloat>(),
@@ -2487,7 +2487,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Sin,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSin),
+    testing::Combine(testing::Values(builtin::Function::kSin),
                      testing::ValuesIn(Concat(SinCases<AFloat>(),  //
                                               SinCases<f32>(),
                                               SinCases<f16>()))));
@@ -2512,7 +2512,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Sinh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSinh),
+    testing::Combine(testing::Values(builtin::Function::kSinh),
                      testing::ValuesIn(Concat(SinhCases<AFloat>(),  //
                                               SinhCases<f32>(),
                                               SinhCases<f16>()))));
@@ -2545,7 +2545,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Smoothstep,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSmoothstep),
+    testing::Combine(testing::Values(builtin::Function::kSmoothstep),
                      testing::ValuesIn(Concat(SmoothstepCases<AFloat>(),  //
                                               SmoothstepCases<f32>(),
                                               SmoothstepCases<f16>()))));
@@ -2577,7 +2577,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Step,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kStep),
+    testing::Combine(testing::Values(builtin::Function::kStep),
                      testing::ValuesIn(Concat(StepCases<AFloat>(),  //
                                               StepCases<f32>(),
                                               StepCases<f16>()))));
@@ -2598,7 +2598,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Sqrt,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kSqrt),
+    testing::Combine(testing::Values(builtin::Function::kSqrt),
                      testing::ValuesIn(Concat(SqrtCases<AFloat>(),  //
                                               SqrtCases<f32>(),
                                               SqrtCases<f16>()))));
@@ -2617,7 +2617,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Tan,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kTan),
+    testing::Combine(testing::Values(builtin::Function::kTan),
                      testing::ValuesIn(Concat(TanCases<AFloat>(),  //
                                               TanCases<f32>(),
                                               TanCases<f16>()))));
@@ -2637,7 +2637,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Tanh,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kTanh),
+    testing::Combine(testing::Values(builtin::Function::kTanh),
                      testing::ValuesIn(Concat(TanhCases<AFloat>(),  //
                                               TanhCases<f32>(),
                                               TanhCases<f16>()))));
@@ -2703,7 +2703,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Transpose,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kTranspose),
+    testing::Combine(testing::Values(builtin::Function::kTranspose),
                      testing::ValuesIn(Concat(TransposeCases<AFloat>(),  //
                                               TransposeCases<f32>(),
                                               TransposeCases<f16>()))));
@@ -2721,7 +2721,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Trunc,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kTrunc),
+    testing::Combine(testing::Values(builtin::Function::kTrunc),
                      testing::ValuesIn(Concat(TruncCases<AFloat>(),  //
                                               TruncCases<f32>(),
                                               TruncCases<f16>()))));
@@ -2742,7 +2742,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Unpack4x8snorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kUnpack4X8Snorm),
+    testing::Combine(testing::Values(builtin::Function::kUnpack4X8Snorm),
                      testing::ValuesIn(Unpack4x8snormCases())));
 
 std::vector<Case> Unpack4x8unormCases() {
@@ -2759,7 +2759,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Unpack4x8unorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kUnpack4X8Unorm),
+    testing::Combine(testing::Values(builtin::Function::kUnpack4X8Unorm),
                      testing::ValuesIn(Unpack4x8unormCases())));
 
 std::vector<Case> Unpack2x16floatCases() {
@@ -2773,7 +2773,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Unpack2x16float,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Float),
+    testing::Combine(testing::Values(builtin::Function::kUnpack2X16Float),
                      testing::ValuesIn(Unpack2x16floatCases())));
 
 std::vector<Case> Unpack2x16snormCases() {
@@ -2791,7 +2791,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Unpack2x16snorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Snorm),
+    testing::Combine(testing::Values(builtin::Function::kUnpack2X16Snorm),
                      testing::ValuesIn(Unpack2x16snormCases())));
 
 std::vector<Case> Unpack2x16unormCases() {
@@ -2805,7 +2805,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     Unpack2x16unorm,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Unorm),
+    testing::Combine(testing::Values(builtin::Function::kUnpack2X16Unorm),
                      testing::ValuesIn(Unpack2x16unormCases())));
 
 std::vector<Case> QuantizeToF16Cases() {
@@ -2864,7 +2864,7 @@
 INSTANTIATE_TEST_SUITE_P(  //
     QuantizeToF16,
     ResolverConstEvalBuiltinTest,
-    testing::Combine(testing::Values(sem::BuiltinType::kQuantizeToF16),
+    testing::Combine(testing::Values(builtin::Function::kQuantizeToF16),
                      testing::ValuesIn(QuantizeToF16Cases())));
 
 }  // namespace
diff --git a/src/tint/resolver/const_eval_construction_test.cc b/src/tint/resolver/const_eval_construction_test.cc
index 55c2cf5..e98d21f 100644
--- a/src/tint/resolver/const_eval_construction_test.cc
+++ b/src/tint/resolver/const_eval_construction_test.cc
@@ -30,7 +30,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::AbstractFloat>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<AFloat>(), 99.0f);
@@ -47,7 +46,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::AbstractInt>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<AInt>(), 99);
@@ -63,7 +61,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<AInt>(), 99);
@@ -79,7 +76,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::U32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<AInt>(), 99u);
@@ -95,7 +91,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<AFloat>().value, 9.9f);
@@ -113,7 +108,6 @@
     EXPECT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::F16>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     // 9.9 is not exactly representable by f16, and should be quantized to 9.8984375
@@ -130,7 +124,6 @@
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->Type()->Is<type::Bool>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<bool>(), true);
@@ -158,7 +151,6 @@
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
 
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
@@ -167,18 +159,15 @@
         EXPECT_EQ(sem->ConstantValue()->ValueAs<f32>(), 0.0f);
     } else if (auto* vec = sem->Type()->As<type::Vector>()) {
         for (size_t i = 0; i < vec->Width(); ++i) {
-            EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllEqual());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
             EXPECT_EQ(sem->ConstantValue()->Index(i)->ValueAs<f32>(), 0.0f);
         }
     } else if (auto* mat = sem->Type()->As<type::Matrix>()) {
         for (size_t i = 0; i < mat->columns(); ++i) {
-            EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllEqual());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
             for (size_t j = 0; j < mat->rows(); ++j) {
-                EXPECT_TRUE(sem->ConstantValue()->Index(i)->Index(j)->AllEqual());
                 EXPECT_TRUE(sem->ConstantValue()->Index(i)->Index(j)->AnyZero());
                 EXPECT_TRUE(sem->ConstantValue()->Index(i)->Index(j)->AllZero());
                 EXPECT_EQ(sem->ConstantValue()->Index(i)->Index(j)->ValueAs<f32>(), 0.0f);
@@ -186,7 +175,6 @@
         }
     } else if (auto* arr = sem->Type()->As<type::Array>()) {
         for (size_t i = 0; i < *(arr->ConstantCount()); ++i) {
-            EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllEqual());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
             EXPECT_EQ(sem->ConstantValue()->Index(i)->ValueAs<f32>(), 0.0f);
@@ -229,21 +217,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 0);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 0);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 0);
@@ -262,21 +246,17 @@
     EXPECT_TRUE(vec->type()->Is<type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 0u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 0u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 0u);
@@ -295,21 +275,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 0._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 0._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 0._a);
@@ -330,21 +306,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 0._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 0._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 0._a);
@@ -363,21 +335,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), false);
@@ -396,21 +364,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 99);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 99);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 99);
@@ -429,21 +393,17 @@
     EXPECT_TRUE(vec->type()->Is<type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 99u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 99u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 99u);
@@ -462,21 +422,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 9.9f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 9.9f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 9.9f);
@@ -497,22 +453,18 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     // 9.9 is not exactly representable by f16, and should be quantized to 9.8984375
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 9.8984375f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 9.8984375f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 9.8984375f);
@@ -531,21 +483,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), true);
@@ -565,21 +513,17 @@
     EXPECT_TRUE(vec->type()->Is<type::AbstractInt>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -599,21 +543,17 @@
     EXPECT_TRUE(vec->type()->Is<type::AbstractFloat>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.0f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.0f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.0f);
@@ -632,21 +572,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -665,21 +601,17 @@
     EXPECT_TRUE(vec->type()->Is<type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -698,21 +630,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.f);
@@ -733,21 +661,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.f);
@@ -766,21 +690,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), true);
@@ -799,21 +719,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -832,21 +748,17 @@
     EXPECT_TRUE(vec->type()->Is<type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -865,21 +777,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.f);
@@ -898,21 +806,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 10_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 10_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 10_f);
@@ -931,21 +835,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0_f);
@@ -964,21 +864,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), -0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), -0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), -0_f);
@@ -997,21 +893,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), -0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0_f);
@@ -1032,21 +924,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.f);
@@ -1067,21 +955,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f16>(), 10_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f16>(), 10_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f16>(), 10_h);
@@ -1102,21 +986,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f16>(), 0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f16>(), 0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f16>(), 0_h);
@@ -1137,21 +1017,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f16>(), -0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f16>(), -0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f16>(), -0_h);
@@ -1172,21 +1048,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f16>(), 0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f16>(), -0_h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f16>(), 0_h);
@@ -1205,21 +1077,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), true);
@@ -1238,21 +1106,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), true);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), true);
@@ -1271,21 +1135,17 @@
     EXPECT_TRUE(vec->type()->Is<type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<bool>(), false);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<bool>(), false);
@@ -1305,36 +1165,29 @@
     EXPECT_EQ(mat->columns(), 2u);
     EXPECT_EQ(mat->rows(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0._f);
@@ -1356,36 +1209,29 @@
     EXPECT_EQ(mat->columns(), 2u);
     EXPECT_EQ(mat->rows(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f16>(), 0._h);
@@ -1405,36 +1251,29 @@
     EXPECT_EQ(mat->columns(), 3u);
     EXPECT_EQ(mat->rows(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<AFloat>(), 1._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<AFloat>(), 2._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<AFloat>(), 3._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<AFloat>(), 4._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->ValueAs<AFloat>(), 5._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->ValueAs<AFloat>(), 6._a);
@@ -1457,36 +1296,29 @@
     EXPECT_EQ(mat->columns(), 3u);
     EXPECT_EQ(mat->rows(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<AFloat>(), 1._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<AFloat>(), 2._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<AFloat>(), 3._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<AFloat>(), 4._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->ValueAs<AFloat>(), 5._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->ValueAs<AFloat>(), 6._a);
@@ -1504,26 +1336,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<i32>(), 0_i);
@@ -1541,26 +1368,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f32>(), 0_f);
@@ -1578,36 +1400,29 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0_f);
@@ -1629,26 +1444,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<sem::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 0_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 0_f);
@@ -1666,26 +1476,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 10_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<i32>(), 20_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<i32>(), 30_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<i32>(), 40_i);
@@ -1765,17 +1570,13 @@
     EXPECT_TRUE(outer_arr->ElemType()->As<type::Array>()->ElemType()->Is<type::F32>());
 
     auto* arr = sem->ConstantValue();
-    EXPECT_FALSE(arr->AllEqual());
     EXPECT_FALSE(arr->AnyZero());
     EXPECT_FALSE(arr->AllZero());
 
-    EXPECT_FALSE(arr->Index(0)->AllEqual());
     EXPECT_FALSE(arr->Index(0)->AnyZero());
     EXPECT_FALSE(arr->Index(0)->AllZero());
-    EXPECT_FALSE(arr->Index(1)->AllEqual());
     EXPECT_FALSE(arr->Index(1)->AnyZero());
     EXPECT_FALSE(arr->Index(1)->AllZero());
-    EXPECT_FALSE(arr->Index(2)->AllEqual());
     EXPECT_FALSE(arr->Index(2)->AnyZero());
     EXPECT_FALSE(arr->Index(2)->AllZero());
 
@@ -1799,26 +1600,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 10_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 20_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 30_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f32>(), 40_f);
@@ -1837,7 +1633,6 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 1_f);
@@ -1866,26 +1661,21 @@
     ASSERT_NE(arr, nullptr);
     EXPECT_TRUE(arr->ElemType()->Is<sem::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 1_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 2_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 3_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 4_f);
@@ -1914,7 +1704,6 @@
     EXPECT_EQ(str->Members().Length(), 5u);
 
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
@@ -1930,7 +1719,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(4)->ValueAs<bool>(), false);
 
     for (size_t i = 0; i < str->Members().Length(); ++i) {
-        EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllEqual());
         EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
         EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
     }
@@ -1962,12 +1750,10 @@
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 1u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
     auto* inner_struct = sem->ConstantValue()->Index(0);
-    EXPECT_FALSE(inner_struct->AllEqual());
     EXPECT_TRUE(inner_struct->AnyZero());
     EXPECT_TRUE(inner_struct->AllZero());
 
@@ -1983,7 +1769,6 @@
     EXPECT_EQ(inner_struct->Index(4)->ValueAs<bool>(), false);
 
     for (size_t i = 0; i < str->Members().Length(); ++i) {
-        EXPECT_TRUE(inner_struct->Index(i)->AllEqual());
         EXPECT_TRUE(inner_struct->Index(i)->AnyZero());
         EXPECT_TRUE(inner_struct->Index(i)->AllZero());
     }
@@ -2004,23 +1789,19 @@
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::I32>());
@@ -2049,35 +1830,29 @@
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<u32>(), 0_u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Bool>());
@@ -2102,11 +1877,9 @@
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
@@ -2116,7 +1889,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
@@ -2126,7 +1898,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
@@ -2159,11 +1930,9 @@
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
@@ -2172,7 +1941,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<i32>(), 0_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
@@ -2182,7 +1950,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<u32>(), 0_u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
@@ -2193,7 +1960,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(3)->ValueAs<f32>(), 0._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
@@ -2203,7 +1969,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->ValueAs<f16>(), 0._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->ValueAs<f16>(), 0._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
@@ -2236,11 +2001,9 @@
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Struct>());
@@ -2248,7 +2011,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0_f);
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Struct>());
@@ -2279,35 +2041,29 @@
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 1_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<u32>(), 2_u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 3._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f16>(), 4._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Bool>());
@@ -2337,11 +2093,9 @@
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
@@ -2350,7 +2104,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<i32>(), 1_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
@@ -2360,7 +2113,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<u32>(), 2_u);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
@@ -2371,7 +2123,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->ValueAs<f32>(), 3._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(3)->ValueAs<f32>(), 3._f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
@@ -2381,7 +2132,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->ValueAs<f16>(), 4._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->ValueAs<f16>(), 4._h);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
@@ -2415,11 +2165,9 @@
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Struct>());
@@ -2427,7 +2175,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 3_f);
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Struct>());
@@ -2454,18 +2201,15 @@
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Array>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 2_i);
 
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Array>());
diff --git a/src/tint/resolver/const_eval_conversion_test.cc b/src/tint/resolver/const_eval_conversion_test.cc
index 92af2de..350afb2 100644
--- a/src/tint/resolver/const_eval_conversion_test.cc
+++ b/src/tint/resolver/const_eval_conversion_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "src/tint/resolver/const_eval_test.h"
+#include "src/tint/sem/materialize.h"
 
 using namespace tint::number_suffixes;  // NOLINT
 
@@ -235,21 +236,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3);
@@ -268,21 +265,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 10.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 20.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 30.f);
@@ -303,21 +296,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), 1_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), 2_i);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), 3_i);
@@ -338,21 +327,17 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 10.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), 20.f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 30.f);
@@ -371,21 +356,17 @@
     EXPECT_TRUE(vec->type()->Is<type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), i32::Highest());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), i32::Lowest());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), i32::Highest());
@@ -404,21 +385,17 @@
     EXPECT_TRUE(vec->type()->Is<type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AInt>(), u32::Highest());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AInt>(), u32::Lowest());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AInt>(), u32::Highest());
@@ -449,28 +426,69 @@
     EXPECT_TRUE(vec->type()->Is<type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<AFloat>(), 0.0);
     EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(0)->ValueAs<AFloat>().value));
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<AFloat>(), -0.0);
     EXPECT_TRUE(std::signbit(sem->ConstantValue()->Index(1)->ValueAs<AFloat>().value));
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<AFloat>(), 0.0);
     EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(2)->ValueAs<AFloat>().value));
 }
 
+TEST_F(ResolverConstEvalTest, StructAbstractSplat_to_StructDifferentTypes) {
+    // fn f() {
+    //   const c = modf(4.0);
+    //   var v = c;
+    // }
+    auto* expr_c = Call(builtin::Function::kModf, 0_a);
+    auto* materialized = Expr("c");
+    WrapInFunction(Decl(Const("c", expr_c)), Decl(Var("v", materialized)));
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* c = Sem().Get(expr_c);
+    ASSERT_NE(c, nullptr);
+    EXPECT_TRUE(c->ConstantValue()->Is<constant::Splat>());
+    EXPECT_TRUE(c->ConstantValue()->AnyZero());
+    EXPECT_TRUE(c->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(c->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_TRUE(c->ConstantValue()->Index(0)->AllZero());
+    EXPECT_TRUE(c->ConstantValue()->Index(0)->Type()->Is<type::AbstractFloat>());
+    EXPECT_EQ(c->ConstantValue()->Index(0)->ValueAs<AFloat>(), 0_f);
+
+    EXPECT_TRUE(c->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_TRUE(c->ConstantValue()->Index(1)->AllZero());
+    EXPECT_TRUE(c->ConstantValue()->Index(1)->Type()->Is<type::AbstractFloat>());
+    EXPECT_EQ(c->ConstantValue()->Index(1)->ValueAs<AFloat>(), 0_a);
+
+    auto* v = Sem().GetVal(materialized);
+    ASSERT_NE(v, nullptr);
+    EXPECT_TRUE(v->Is<sem::Materialize>());
+    EXPECT_TRUE(v->ConstantValue()->Is<constant::Splat>());
+    EXPECT_TRUE(v->ConstantValue()->AnyZero());
+    EXPECT_TRUE(v->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(v->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_TRUE(v->ConstantValue()->Index(0)->AllZero());
+    EXPECT_TRUE(v->ConstantValue()->Index(0)->Type()->Is<type::F32>());
+    EXPECT_EQ(v->ConstantValue()->Index(0)->ValueAs<f32>(), 0_f);
+
+    EXPECT_TRUE(v->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_TRUE(v->ConstantValue()->Index(1)->AllZero());
+    EXPECT_TRUE(v->ConstantValue()->Index(1)->Type()->Is<type::F32>());
+    EXPECT_EQ(v->ConstantValue()->Index(1)->ValueAs<f32>(), 0_f);
+}
+
 }  // namespace
 }  // namespace tint::resolver
diff --git a/src/tint/resolver/const_eval_indexing_test.cc b/src/tint/resolver/const_eval_indexing_test.cc
index 4d8c8cb..d311d30 100644
--- a/src/tint/resolver/const_eval_indexing_test.cc
+++ b/src/tint/resolver/const_eval_indexing_test.cc
@@ -29,7 +29,6 @@
     ASSERT_NE(sem, nullptr);
     ASSERT_TRUE(sem->Type()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<i32>(), 3_i);
@@ -133,7 +132,6 @@
     ASSERT_NE(sem, nullptr);
     ASSERT_TRUE(sem->Type()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<i32>(), 2_i);
@@ -152,12 +150,10 @@
     EXPECT_EQ(vec->Width(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 3._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 1._a);
@@ -174,7 +170,6 @@
     ASSERT_NE(sem, nullptr);
     ASSERT_TRUE(sem->Type()->Is<type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_TRUE(sem->ConstantValue()->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
     EXPECT_EQ(sem->ConstantValue()->ValueAs<i32>(), 2_i);
@@ -194,12 +189,10 @@
     EXPECT_EQ(vec->Width(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 5._a);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 6._a);
@@ -241,17 +234,14 @@
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<f32>(), 4_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<f32>(), 5_f);
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 6_f);
@@ -310,36 +300,29 @@
         EXPECT_EQ(ty->columns(), 2u);
         EXPECT_EQ(ty->rows(), 3u);
         EXPECT_EQ(mat->ConstantValue()->Type(), mat->Type());
-        EXPECT_FALSE(mat->ConstantValue()->AllEqual());
         EXPECT_TRUE(mat->ConstantValue()->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->AllZero());
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(0)->Index(0)->AllEqual());
         EXPECT_FALSE(mat->ConstantValue()->Index(0)->Index(0)->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->Index(0)->Index(0)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 7_f);
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(0)->Index(1)->AllEqual());
         EXPECT_TRUE(mat->ConstantValue()->Index(0)->Index(1)->AnyZero());
         EXPECT_TRUE(mat->ConstantValue()->Index(0)->Index(1)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0_f);
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(0)->Index(2)->AllEqual());
         EXPECT_FALSE(mat->ConstantValue()->Index(0)->Index(2)->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->Index(0)->Index(2)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 9_f);
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(1)->Index(0)->AllEqual());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(0)->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(0)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 10_f);
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(1)->Index(1)->AllEqual());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(1)->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(1)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 11_f);
 
-        EXPECT_TRUE(mat->ConstantValue()->Index(1)->Index(2)->AllEqual());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(2)->AnyZero());
         EXPECT_FALSE(mat->ConstantValue()->Index(1)->Index(2)->AllZero());
         EXPECT_EQ(mat->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 12_f);
@@ -352,21 +335,17 @@
         EXPECT_TRUE(ty->type()->Is<type::F32>());
         EXPECT_EQ(ty->Width(), 3u);
         EXPECT_EQ(vec->ConstantValue()->Type(), vec->Type());
-        EXPECT_FALSE(vec->ConstantValue()->AllEqual());
         EXPECT_TRUE(vec->ConstantValue()->AnyZero());
         EXPECT_FALSE(vec->ConstantValue()->AllZero());
 
-        EXPECT_TRUE(vec->ConstantValue()->Index(0)->AllEqual());
         EXPECT_FALSE(vec->ConstantValue()->Index(0)->AnyZero());
         EXPECT_FALSE(vec->ConstantValue()->Index(0)->AllZero());
         EXPECT_EQ(vec->ConstantValue()->Index(0)->ValueAs<f32>(), 7_f);
 
-        EXPECT_TRUE(vec->ConstantValue()->Index(1)->AllEqual());
         EXPECT_TRUE(vec->ConstantValue()->Index(1)->AnyZero());
         EXPECT_TRUE(vec->ConstantValue()->Index(1)->AllZero());
         EXPECT_EQ(vec->ConstantValue()->Index(1)->ValueAs<f32>(), 0_f);
 
-        EXPECT_TRUE(vec->ConstantValue()->Index(2)->AllEqual());
         EXPECT_FALSE(vec->ConstantValue()->Index(2)->AnyZero());
         EXPECT_FALSE(vec->ConstantValue()->Index(2)->AllZero());
         EXPECT_EQ(vec->ConstantValue()->Index(2)->ValueAs<f32>(), 9_f);
@@ -376,7 +355,6 @@
         EXPECT_NE(f, nullptr);
         EXPECT_TRUE(f->Type()->Is<type::F32>());
         EXPECT_EQ(f->ConstantValue()->Type(), f->Type());
-        EXPECT_TRUE(f->ConstantValue()->AllEqual());
         EXPECT_FALSE(f->ConstantValue()->AnyZero());
         EXPECT_FALSE(f->ConstantValue()->AllZero());
         EXPECT_EQ(f->ConstantValue()->ValueAs<f32>(), 9_f);
diff --git a/src/tint/resolver/const_eval_member_access_test.cc b/src/tint/resolver/const_eval_member_access_test.cc
index 4fcba8b..9a74e6c 100644
--- a/src/tint/resolver/const_eval_member_access_test.cc
+++ b/src/tint/resolver/const_eval_member_access_test.cc
@@ -46,13 +46,11 @@
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(outer->ConstantValue(), nullptr);
     EXPECT_TYPE(outer->ConstantValue()->Type(), outer->Type());
-    EXPECT_FALSE(outer->ConstantValue()->AllEqual());
     EXPECT_TRUE(outer->ConstantValue()->AnyZero());
     EXPECT_FALSE(outer->ConstantValue()->AllZero());
 
     auto* o1 = Sem().Get(o1_expr);
     ASSERT_NE(o1->ConstantValue(), nullptr);
-    EXPECT_FALSE(o1->ConstantValue()->AllEqual());
     EXPECT_FALSE(o1->ConstantValue()->AnyZero());
     EXPECT_FALSE(o1->ConstantValue()->AllZero());
     EXPECT_TRUE(o1->ConstantValue()->Type()->Is<sem::Struct>());
@@ -63,7 +61,6 @@
 
     auto* i2 = Sem().Get(i2_expr);
     ASSERT_NE(i2->ConstantValue(), nullptr);
-    EXPECT_TRUE(i2->ConstantValue()->AllEqual());
     EXPECT_FALSE(i2->ConstantValue()->AnyZero());
     EXPECT_FALSE(i2->ConstantValue()->AllZero());
     EXPECT_TRUE(i2->ConstantValue()->Type()->Is<type::U32>());
@@ -85,7 +82,6 @@
     EXPECT_TYPE(cv->Type(), sem->Type());
     EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
     EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::AbstractFloat>());
-    EXPECT_FALSE(cv->AllEqual());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
     auto* c0 = cv->Index(0);
@@ -124,7 +120,6 @@
     EXPECT_TYPE(cv->Type(), sem->Type());
     EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
     EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::AbstractFloat>());
-    EXPECT_FALSE(cv->AllEqual());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
 
@@ -201,7 +196,6 @@
     EXPECT_TYPE(cv->Type(), sem->Type());
     EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
     EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::F32>());
-    EXPECT_FALSE(cv->AllEqual());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
 
diff --git a/src/tint/resolver/const_eval_test.h b/src/tint/resolver/const_eval_test.h
index de25b20..8cbea04 100644
--- a/src/tint/resolver/const_eval_test.h
+++ b/src/tint/resolver/const_eval_test.h
@@ -23,6 +23,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "src/tint/resolver/resolver_test_helper.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/test_helper.h"
 #include "src/tint/utils/string_stream.h"
 
diff --git a/src/tint/resolver/dependency_graph.cc b/src/tint/resolver/dependency_graph.cc
index f718a46..47e691c 100644
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -60,6 +60,7 @@
 #include "src/tint/builtin/builtin_value.h"
 #include "src/tint/scope_stack.h"
 #include "src/tint/sem/builtin.h"
+#include "src/tint/switch.h"
 #include "src/tint/symbol_table.h"
 #include "src/tint/utils/block_allocator.h"
 #include "src/tint/utils/compiler_macros.h"
@@ -440,7 +441,8 @@
         auto* resolved = scope_stack_.Get(to);
         if (!resolved) {
             auto s = symbols_.NameFor(to);
-            if (auto builtin_fn = sem::ParseBuiltinType(s); builtin_fn != sem::BuiltinType::kNone) {
+            if (auto builtin_fn = builtin::ParseFunction(s);
+                builtin_fn != builtin::Function::kNone) {
                 graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_fn));
                 return;
             }
@@ -838,7 +840,7 @@
                 return "<unknown>";
             });
     }
-    if (auto builtin_fn = BuiltinFunction(); builtin_fn != sem::BuiltinType::kNone) {
+    if (auto builtin_fn = BuiltinFunction(); builtin_fn != builtin::Function::kNone) {
         return "builtin function '" + utils::ToString(builtin_fn) + "'";
     }
     if (auto builtin_ty = BuiltinType(); builtin_ty != builtin::Builtin::kUndefined) {
diff --git a/src/tint/resolver/dependency_graph.h b/src/tint/resolver/dependency_graph.h
index 429a47a..f58b2a2 100644
--- a/src/tint/resolver/dependency_graph.h
+++ b/src/tint/resolver/dependency_graph.h
@@ -22,11 +22,11 @@
 #include "src/tint/builtin/access.h"
 #include "src/tint/builtin/builtin.h"
 #include "src/tint/builtin/builtin_value.h"
+#include "src/tint/builtin/function.h"
 #include "src/tint/builtin/interpolation_sampling.h"
 #include "src/tint/builtin/interpolation_type.h"
 #include "src/tint/builtin/texel_format.h"
 #include "src/tint/diagnostic/diagnostic.h"
-#include "src/tint/sem/builtin_type.h"
 #include "src/tint/symbol_table.h"
 #include "src/tint/utils/hashmap.h"
 
@@ -44,7 +44,7 @@
 /// - const ast::TypeDecl*  (as const ast::Node*)
 /// - const ast::Variable*  (as const ast::Node*)
 /// - const ast::Function*  (as const ast::Node*)
-/// - sem::BuiltinType
+/// - builtin::Function
 /// - builtin::Access
 /// - builtin::AddressSpace
 /// - builtin::Builtin
@@ -75,13 +75,13 @@
         return nullptr;
     }
 
-    /// @return the builtin function if the ResolvedIdentifier holds sem::BuiltinType, otherwise
-    /// sem::BuiltinType::kNone
-    sem::BuiltinType BuiltinFunction() const {
-        if (auto n = std::get_if<sem::BuiltinType>(&value_)) {
+    /// @return the builtin function if the ResolvedIdentifier holds builtin::Function, otherwise
+    /// builtin::Function::kNone
+    builtin::Function BuiltinFunction() const {
+        if (auto n = std::get_if<builtin::Function>(&value_)) {
             return *n;
         }
-        return sem::BuiltinType::kNone;
+        return builtin::Function::kNone;
     }
 
     /// @return the access if the ResolvedIdentifier holds builtin::Access, otherwise
@@ -172,7 +172,7 @@
   private:
     std::variant<UnresolvedIdentifier,
                  const ast::Node*,
-                 sem::BuiltinType,
+                 builtin::Function,
                  builtin::Access,
                  builtin::AddressSpace,
                  builtin::Builtin,
diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc
index c81c336..c9ce3b8 100644
--- a/src/tint/resolver/dependency_graph_test.cc
+++ b/src/tint/resolver/dependency_graph_test.cc
@@ -1181,7 +1181,7 @@
 namespace resolve_to_builtin_func {
 
 using ResolverDependencyGraphResolveToBuiltinFunc =
-    ResolverDependencyGraphTestWithParam<std::tuple<SymbolUseKind, sem::BuiltinType>>;
+    ResolverDependencyGraphTestWithParam<std::tuple<SymbolUseKind, builtin::Function>>;
 
 TEST_P(ResolverDependencyGraphResolveToBuiltinFunc, Resolve) {
     const auto use = std::get<0>(GetParam());
@@ -1200,17 +1200,17 @@
 INSTANTIATE_TEST_SUITE_P(Types,
                          ResolverDependencyGraphResolveToBuiltinFunc,
                          testing::Combine(testing::ValuesIn(kTypeUseKinds),
-                                          testing::ValuesIn(sem::kBuiltinTypes)));
+                                          testing::ValuesIn(builtin::kFunctions)));
 
 INSTANTIATE_TEST_SUITE_P(Values,
                          ResolverDependencyGraphResolveToBuiltinFunc,
                          testing::Combine(testing::ValuesIn(kValueUseKinds),
-                                          testing::ValuesIn(sem::kBuiltinTypes)));
+                                          testing::ValuesIn(builtin::kFunctions)));
 
 INSTANTIATE_TEST_SUITE_P(Functions,
                          ResolverDependencyGraphResolveToBuiltinFunc,
                          testing::Combine(testing::ValuesIn(kFuncUseKinds),
-                                          testing::ValuesIn(sem::kBuiltinTypes)));
+                                          testing::ValuesIn(builtin::kFunctions)));
 
 }  // namespace resolve_to_builtin_func
 
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index e8fe271..18e2f81 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -24,6 +24,7 @@
 #include "src/tint/sem/pipeline_stage_set.h"
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/abstract_float.h"
 #include "src/tint/type/abstract_int.h"
 #include "src/tint/type/abstract_numeric.h"
@@ -1096,7 +1097,7 @@
   public:
     explicit Impl(ProgramBuilder& builder);
 
-    Builtin Lookup(sem::BuiltinType builtin_type,
+    Builtin Lookup(builtin::Function builtin_type,
                    utils::VectorRef<const type::Type*> args,
                    sem::EvaluationStage earliest_eval_stage,
                    const Source& source) override;
@@ -1264,11 +1265,11 @@
 
 Impl::Impl(ProgramBuilder& b) : builder(b) {}
 
-Impl::Builtin Impl::Lookup(sem::BuiltinType builtin_type,
+Impl::Builtin Impl::Lookup(builtin::Function builtin_type,
                            utils::VectorRef<const type::Type*> args,
                            sem::EvaluationStage earliest_eval_stage,
                            const Source& source) {
-    const char* intrinsic_name = sem::str(builtin_type);
+    const char* intrinsic_name = builtin::str(builtin_type);
 
     // Generates an error when no overloads match the provided arguments
     auto on_no_match = [&](utils::VectorRef<Candidate> candidates) {
diff --git a/src/tint/resolver/intrinsic_table.h b/src/tint/resolver/intrinsic_table.h
index 515e839..78e2e7a 100644
--- a/src/tint/resolver/intrinsic_table.h
+++ b/src/tint/resolver/intrinsic_table.h
@@ -92,7 +92,7 @@
     ///        after shader creation time (sem::EvaluationStage::kConstant).
     /// @param source the source of the builtin call
     /// @return the semantic builtin if found, otherwise nullptr
-    virtual Builtin Lookup(sem::BuiltinType type,
+    virtual Builtin Lookup(builtin::Function type,
                            utils::VectorRef<const type::Type*> args,
                            sem::EvaluationStage earliest_eval_stage,
                            const Source& source) = 0;
diff --git a/src/tint/resolver/intrinsic_table.inl b/src/tint/resolver/intrinsic_table.inl
index 1683d27..895d489 100644
--- a/src/tint/resolver/intrinsic_table.inl
+++ b/src/tint/resolver/intrinsic_table.inl
@@ -7748,102 +7748,102 @@
   {
     /* [931] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[130],
   },
   {
     /* [932] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[58],
+    /* matcher indices */ &kMatcherIndices[235],
   },
   {
     /* [933] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[116],
+    /* matcher indices */ &kMatcherIndices[237],
   },
   {
     /* [934] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[118],
+    /* matcher indices */ &kMatcherIndices[58],
   },
   {
     /* [935] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[122],
+    /* matcher indices */ &kMatcherIndices[116],
   },
   {
     /* [936] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[124],
+    /* matcher indices */ &kMatcherIndices[118],
   },
   {
     /* [937] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[128],
+    /* matcher indices */ &kMatcherIndices[122],
   },
   {
     /* [938] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[130],
+    /* matcher indices */ &kMatcherIndices[124],
   },
   {
     /* [939] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[128],
   },
   {
     /* [940] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[130],
   },
   {
     /* [941] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[234],
   },
   {
     /* [942] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[235],
   },
   {
     /* [943] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[132],
+    /* matcher indices */ &kMatcherIndices[236],
   },
   {
     /* [944] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[238],
+    /* matcher indices */ &kMatcherIndices[237],
   },
   {
     /* [945] */
-    /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[5],
+    /* usage */ ParameterUsage::kTexture,
+    /* matcher indices */ &kMatcherIndices[132],
   },
   {
     /* [946] */
-    /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[3],
+    /* usage */ ParameterUsage::kTexture,
+    /* matcher indices */ &kMatcherIndices[238],
   },
   {
     /* [947] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[39],
+    /* matcher indices */ &kMatcherIndices[5],
   },
   {
     /* [948] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[37],
+    /* matcher indices */ &kMatcherIndices[3],
   },
   {
     /* [949] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[3],
+    /* matcher indices */ &kMatcherIndices[39],
   },
   {
     /* [950] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[34],
+    /* matcher indices */ &kMatcherIndices[37],
   },
   {
     /* [951] */
@@ -7858,17 +7858,17 @@
   {
     /* [953] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[9],
+    /* matcher indices */ &kMatcherIndices[3],
   },
   {
     /* [954] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[3],
+    /* matcher indices */ &kMatcherIndices[34],
   },
   {
     /* [955] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[105],
+    /* matcher indices */ &kMatcherIndices[9],
   },
   {
     /* [956] */
@@ -7878,7 +7878,7 @@
   {
     /* [957] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[42],
+    /* matcher indices */ &kMatcherIndices[105],
   },
   {
     /* [958] */
@@ -7888,7 +7888,7 @@
   {
     /* [959] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[1],
+    /* matcher indices */ &kMatcherIndices[42],
   },
   {
     /* [960] */
@@ -7898,7 +7898,7 @@
   {
     /* [961] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[39],
+    /* matcher indices */ &kMatcherIndices[1],
   },
   {
     /* [962] */
@@ -7908,7 +7908,7 @@
   {
     /* [963] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[23],
+    /* matcher indices */ &kMatcherIndices[39],
   },
   {
     /* [964] */
@@ -7918,12 +7918,12 @@
   {
     /* [965] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[158],
+    /* matcher indices */ &kMatcherIndices[23],
   },
   {
     /* [966] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[158],
+    /* matcher indices */ &kMatcherIndices[3],
   },
   {
     /* [967] */
@@ -7943,22 +7943,22 @@
   {
     /* [970] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[106],
+    /* matcher indices */ &kMatcherIndices[158],
   },
   {
     /* [971] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[3],
+    /* matcher indices */ &kMatcherIndices[158],
   },
   {
     /* [972] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[160],
+    /* matcher indices */ &kMatcherIndices[106],
   },
   {
     /* [973] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[160],
+    /* matcher indices */ &kMatcherIndices[3],
   },
   {
     /* [974] */
@@ -7978,22 +7978,22 @@
   {
     /* [977] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[134],
+    /* matcher indices */ &kMatcherIndices[160],
   },
   {
     /* [978] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[3],
+    /* matcher indices */ &kMatcherIndices[160],
   },
   {
     /* [979] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[134],
   },
   {
     /* [980] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[3],
   },
   {
     /* [981] */
@@ -8013,141 +8013,151 @@
   {
     /* [984] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[178],
+    /* matcher indices */ &kMatcherIndices[172],
   },
   {
     /* [985] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[180],
+    /* matcher indices */ &kMatcherIndices[172],
   },
   {
     /* [986] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[182],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [987] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[184],
+    /* matcher indices */ &kMatcherIndices[180],
   },
   {
     /* [988] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[186],
+    /* matcher indices */ &kMatcherIndices[182],
   },
   {
     /* [989] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[188],
+    /* matcher indices */ &kMatcherIndices[184],
   },
   {
     /* [990] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[190],
+    /* matcher indices */ &kMatcherIndices[186],
   },
   {
     /* [991] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[192],
+    /* matcher indices */ &kMatcherIndices[188],
   },
   {
     /* [992] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[194],
+    /* matcher indices */ &kMatcherIndices[190],
   },
   {
     /* [993] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[196],
+    /* matcher indices */ &kMatcherIndices[192],
   },
   {
     /* [994] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[198],
+    /* matcher indices */ &kMatcherIndices[194],
   },
   {
     /* [995] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[200],
+    /* matcher indices */ &kMatcherIndices[196],
   },
   {
     /* [996] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[202],
+    /* matcher indices */ &kMatcherIndices[198],
   },
   {
     /* [997] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[204],
+    /* matcher indices */ &kMatcherIndices[200],
   },
   {
     /* [998] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[206],
+    /* matcher indices */ &kMatcherIndices[202],
   },
   {
     /* [999] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[208],
+    /* matcher indices */ &kMatcherIndices[204],
   },
   {
     /* [1000] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[210],
+    /* matcher indices */ &kMatcherIndices[206],
   },
   {
     /* [1001] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[212],
+    /* matcher indices */ &kMatcherIndices[208],
   },
   {
     /* [1002] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[214],
+    /* matcher indices */ &kMatcherIndices[210],
   },
   {
     /* [1003] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[216],
+    /* matcher indices */ &kMatcherIndices[212],
   },
   {
     /* [1004] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[218],
+    /* matcher indices */ &kMatcherIndices[214],
   },
   {
     /* [1005] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[220],
+    /* matcher indices */ &kMatcherIndices[216],
   },
   {
     /* [1006] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[222],
+    /* matcher indices */ &kMatcherIndices[218],
   },
   {
     /* [1007] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[224],
+    /* matcher indices */ &kMatcherIndices[220],
   },
   {
     /* [1008] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[226],
+    /* matcher indices */ &kMatcherIndices[222],
   },
   {
     /* [1009] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[228],
+    /* matcher indices */ &kMatcherIndices[224],
   },
   {
     /* [1010] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[230],
+    /* matcher indices */ &kMatcherIndices[226],
   },
   {
     /* [1011] */
     /* usage */ ParameterUsage::kNone,
+    /* matcher indices */ &kMatcherIndices[228],
+  },
+  {
+    /* [1012] */
+    /* usage */ ParameterUsage::kNone,
+    /* matcher indices */ &kMatcherIndices[230],
+  },
+  {
+    /* [1013] */
+    /* usage */ ParameterUsage::kNone,
     /* matcher indices */ &kMatcherIndices[106],
   },
 };
@@ -8910,7 +8920,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[36],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[134],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -8922,7 +8932,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[977],
+    /* parameters */ &kParameters[979],
     /* return matcher indices */ &kMatcherIndices[134],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -8934,7 +8944,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[978],
+    /* parameters */ &kParameters[980],
     /* return matcher indices */ &kMatcherIndices[134],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::VecSplat,
@@ -9030,7 +9040,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[979],
+    /* parameters */ &kParameters[981],
     /* return matcher indices */ &kMatcherIndices[114],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9042,7 +9052,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[980],
+    /* parameters */ &kParameters[982],
     /* return matcher indices */ &kMatcherIndices[174],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9054,7 +9064,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[18],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[981],
+    /* parameters */ &kParameters[983],
     /* return matcher indices */ &kMatcherIndices[154],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9066,7 +9076,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[20],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[982],
+    /* parameters */ &kParameters[984],
     /* return matcher indices */ &kMatcherIndices[156],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9078,7 +9088,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[983],
+    /* parameters */ &kParameters[985],
     /* return matcher indices */ &kMatcherIndices[176],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9546,7 +9556,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[36],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[106],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -9558,7 +9568,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[970],
+    /* parameters */ &kParameters[972],
     /* return matcher indices */ &kMatcherIndices[106],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -9570,7 +9580,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[971],
+    /* parameters */ &kParameters[973],
     /* return matcher indices */ &kMatcherIndices[106],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::VecSplat,
@@ -9618,7 +9628,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[972],
+    /* parameters */ &kParameters[974],
     /* return matcher indices */ &kMatcherIndices[138],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9630,7 +9640,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[973],
+    /* parameters */ &kParameters[975],
     /* return matcher indices */ &kMatcherIndices[168],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9642,7 +9652,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[18],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[974],
+    /* parameters */ &kParameters[976],
     /* return matcher indices */ &kMatcherIndices[148],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9654,7 +9664,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[20],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[975],
+    /* parameters */ &kParameters[977],
     /* return matcher indices */ &kMatcherIndices[126],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9666,7 +9676,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[976],
+    /* parameters */ &kParameters[978],
     /* return matcher indices */ &kMatcherIndices[170],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -9678,7 +9688,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[933],
+    /* parameters */ &kParameters[935],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9690,7 +9700,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[934],
+    /* parameters */ &kParameters[936],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9702,7 +9712,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[935],
+    /* parameters */ &kParameters[937],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9714,7 +9724,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[936],
+    /* parameters */ &kParameters[938],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9726,7 +9736,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[937],
+    /* parameters */ &kParameters[939],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9738,7 +9748,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[938],
+    /* parameters */ &kParameters[940],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9750,7 +9760,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[939],
+    /* parameters */ &kParameters[941],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9762,7 +9772,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[940],
+    /* parameters */ &kParameters[942],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9774,7 +9784,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[941],
+    /* parameters */ &kParameters[943],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -9786,7 +9796,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[942],
+    /* parameters */ &kParameters[944],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
@@ -10014,7 +10024,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[36],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[23],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10026,7 +10036,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[963],
+    /* parameters */ &kParameters[965],
     /* return matcher indices */ &kMatcherIndices[23],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10038,7 +10048,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[27],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[964],
+    /* parameters */ &kParameters[966],
     /* return matcher indices */ &kMatcherIndices[23],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::VecSplat,
@@ -10062,7 +10072,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[965],
+    /* parameters */ &kParameters[967],
     /* return matcher indices */ &kMatcherIndices[112],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10074,7 +10084,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[966],
+    /* parameters */ &kParameters[968],
     /* return matcher indices */ &kMatcherIndices[164],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10086,7 +10096,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[18],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[967],
+    /* parameters */ &kParameters[969],
     /* return matcher indices */ &kMatcherIndices[136],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10098,7 +10108,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[20],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[968],
+    /* parameters */ &kParameters[970],
     /* return matcher indices */ &kMatcherIndices[120],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10110,7 +10120,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[969],
+    /* parameters */ &kParameters[971],
     /* return matcher indices */ &kMatcherIndices[166],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10530,7 +10540,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[178],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10542,7 +10552,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[984],
+    /* parameters */ &kParameters[986],
     /* return matcher indices */ &kMatcherIndices[178],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10578,7 +10588,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[985],
+    /* parameters */ &kParameters[987],
     /* return matcher indices */ &kMatcherIndices[182],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10590,7 +10600,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[986],
+    /* parameters */ &kParameters[988],
     /* return matcher indices */ &kMatcherIndices[180],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10602,7 +10612,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[184],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10614,7 +10624,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[987],
+    /* parameters */ &kParameters[989],
     /* return matcher indices */ &kMatcherIndices[184],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10650,7 +10660,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[988],
+    /* parameters */ &kParameters[990],
     /* return matcher indices */ &kMatcherIndices[188],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10662,7 +10672,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[989],
+    /* parameters */ &kParameters[991],
     /* return matcher indices */ &kMatcherIndices[186],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10674,7 +10684,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[190],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10686,7 +10696,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[990],
+    /* parameters */ &kParameters[992],
     /* return matcher indices */ &kMatcherIndices[190],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10722,7 +10732,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[991],
+    /* parameters */ &kParameters[993],
     /* return matcher indices */ &kMatcherIndices[194],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10734,7 +10744,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[992],
+    /* parameters */ &kParameters[994],
     /* return matcher indices */ &kMatcherIndices[192],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10746,7 +10756,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[196],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10758,7 +10768,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[993],
+    /* parameters */ &kParameters[995],
     /* return matcher indices */ &kMatcherIndices[196],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10794,7 +10804,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[994],
+    /* parameters */ &kParameters[996],
     /* return matcher indices */ &kMatcherIndices[200],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10806,7 +10816,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[995],
+    /* parameters */ &kParameters[997],
     /* return matcher indices */ &kMatcherIndices[198],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10818,7 +10828,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[202],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10830,7 +10840,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[996],
+    /* parameters */ &kParameters[998],
     /* return matcher indices */ &kMatcherIndices[202],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10866,7 +10876,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[997],
+    /* parameters */ &kParameters[999],
     /* return matcher indices */ &kMatcherIndices[206],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10878,7 +10888,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[998],
+    /* parameters */ &kParameters[1000],
     /* return matcher indices */ &kMatcherIndices[204],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10890,7 +10900,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[208],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10902,7 +10912,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[999],
+    /* parameters */ &kParameters[1001],
     /* return matcher indices */ &kMatcherIndices[208],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -10938,7 +10948,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1000],
+    /* parameters */ &kParameters[1002],
     /* return matcher indices */ &kMatcherIndices[212],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10950,7 +10960,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1001],
+    /* parameters */ &kParameters[1003],
     /* return matcher indices */ &kMatcherIndices[210],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -10962,7 +10972,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[214],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -10974,7 +10984,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1002],
+    /* parameters */ &kParameters[1004],
     /* return matcher indices */ &kMatcherIndices[214],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -11010,7 +11020,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1003],
+    /* parameters */ &kParameters[1005],
     /* return matcher indices */ &kMatcherIndices[218],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -11022,7 +11032,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1004],
+    /* parameters */ &kParameters[1006],
     /* return matcher indices */ &kMatcherIndices[216],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -11034,7 +11044,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[220],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -11046,7 +11056,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1005],
+    /* parameters */ &kParameters[1007],
     /* return matcher indices */ &kMatcherIndices[220],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -11082,7 +11092,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1006],
+    /* parameters */ &kParameters[1008],
     /* return matcher indices */ &kMatcherIndices[224],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -11094,7 +11104,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1007],
+    /* parameters */ &kParameters[1009],
     /* return matcher indices */ &kMatcherIndices[222],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -11106,7 +11116,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ &kMatcherIndices[226],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
@@ -11118,7 +11128,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1008],
+    /* parameters */ &kParameters[1010],
     /* return matcher indices */ &kMatcherIndices[226],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
@@ -11154,7 +11164,7 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1009],
+    /* parameters */ &kParameters[1011],
     /* return matcher indices */ &kMatcherIndices[230],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -11166,397 +11176,13 @@
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1010],
+    /* parameters */ &kParameters[1012],
     /* return matcher indices */ &kMatcherIndices[228],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
     /* [231] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[672],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpPlus,
-  },
-  {
-    /* [232] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[674],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpPlus,
-  },
-  {
-    /* [233] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[676],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpPlus,
-  },
-  {
-    /* [234] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[678],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpPlus,
-  },
-  {
-    /* [235] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[680],
-    /* return matcher indices */ &kMatcherIndices[14],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpPlus,
-  },
-  {
-    /* [236] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[682],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMinus,
-  },
-  {
-    /* [237] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[684],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMinus,
-  },
-  {
-    /* [238] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[686],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMinus,
-  },
-  {
-    /* [239] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[688],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMinus,
-  },
-  {
-    /* [240] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[690],
-    /* return matcher indices */ &kMatcherIndices[14],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMinus,
-  },
-  {
-    /* [241] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[710],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpDivide,
-  },
-  {
-    /* [242] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[712],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpDivide,
-  },
-  {
-    /* [243] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[714],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpDivide,
-  },
-  {
-    /* [244] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[716],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpDivide,
-  },
-  {
-    /* [245] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[718],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpModulo,
-  },
-  {
-    /* [246] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[720],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpModulo,
-  },
-  {
-    /* [247] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[722],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpModulo,
-  },
-  {
-    /* [248] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[724],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpModulo,
-  },
-  {
-    /* [249] */
-    /* num parameters */ 2,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[730],
-    /* return matcher indices */ &kMatcherIndices[39],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpAnd,
-  },
-  {
-    /* [250] */
-    /* num parameters */ 2,
-    /* num template types */ 0,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[732],
-    /* return matcher indices */ &kMatcherIndices[37],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpAnd,
-  },
-  {
-    /* [251] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[734],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpAnd,
-  },
-  {
-    /* [252] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[736],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpAnd,
-  },
-  {
-    /* [253] */
-    /* num parameters */ 2,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[738],
-    /* return matcher indices */ &kMatcherIndices[39],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpOr,
-  },
-  {
-    /* [254] */
-    /* num parameters */ 2,
-    /* num template types */ 0,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[740],
-    /* return matcher indices */ &kMatcherIndices[37],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpOr,
-  },
-  {
-    /* [255] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[742],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpOr,
-  },
-  {
-    /* [256] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[744],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpOr,
-  },
-  {
-    /* [257] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[468],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::mix,
-  },
-  {
-    /* [258] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[471],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::mix,
-  },
-  {
-    /* [259] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[474],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::mix,
-  },
-  {
-    /* [260] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[27],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[480],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::select_bool,
-  },
-  {
-    /* [261] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[27],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[483],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::select_bool,
-  },
-  {
-    /* [262] */
-    /* num parameters */ 3,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[27],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[486],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::select_boolvec,
-  },
-  {
-    /* [263] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11568,11 +11194,11 @@
     /* const eval */ nullptr,
   },
   {
-    /* [264] */
+    /* [232] */
     /* num parameters */ 1,
-    /* num template types */ 0,
+    /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
+    /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[931],
     /* return matcher indices */ &kMatcherIndices[105],
@@ -11580,199 +11206,607 @@
     /* const eval */ nullptr,
   },
   {
-    /* [265] */
+    /* [233] */
     /* num parameters */ 1,
     /* num template types */ 0,
-    /* num template numbers */ 2,
+    /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[6],
+    /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[932],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
   },
   {
-    /* [266] */
-    /* num parameters */ 0,
+    /* [234] */
+    /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[9],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* parameters */ &kParameters[933],
+    /* return matcher indices */ &kMatcherIndices[105],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [235] */
+    /* num parameters */ 1,
+    /* num template types */ 0,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[6],
+    /* parameters */ &kParameters[934],
+    /* return matcher indices */ &kMatcherIndices[105],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [236] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[672],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpPlus,
+  },
+  {
+    /* [237] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[674],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpPlus,
+  },
+  {
+    /* [238] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[676],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpPlus,
+  },
+  {
+    /* [239] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[678],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpPlus,
+  },
+  {
+    /* [240] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[680],
+    /* return matcher indices */ &kMatcherIndices[14],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpPlus,
+  },
+  {
+    /* [241] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[682],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMinus,
+  },
+  {
+    /* [242] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[684],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMinus,
+  },
+  {
+    /* [243] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[686],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMinus,
+  },
+  {
+    /* [244] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[688],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMinus,
+  },
+  {
+    /* [245] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[690],
+    /* return matcher indices */ &kMatcherIndices[14],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMinus,
+  },
+  {
+    /* [246] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[710],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpDivide,
+  },
+  {
+    /* [247] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[712],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpDivide,
+  },
+  {
+    /* [248] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[714],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpDivide,
+  },
+  {
+    /* [249] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[716],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpDivide,
+  },
+  {
+    /* [250] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[718],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpModulo,
+  },
+  {
+    /* [251] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[720],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpModulo,
+  },
+  {
+    /* [252] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[722],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpModulo,
+  },
+  {
+    /* [253] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[724],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpModulo,
+  },
+  {
+    /* [254] */
+    /* num parameters */ 2,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[730],
+    /* return matcher indices */ &kMatcherIndices[39],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpAnd,
+  },
+  {
+    /* [255] */
+    /* num parameters */ 2,
+    /* num template types */ 0,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[732],
+    /* return matcher indices */ &kMatcherIndices[37],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpAnd,
+  },
+  {
+    /* [256] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[29],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[734],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpAnd,
+  },
+  {
+    /* [257] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[29],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[736],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpAnd,
+  },
+  {
+    /* [258] */
+    /* num parameters */ 2,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[738],
+    /* return matcher indices */ &kMatcherIndices[39],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpOr,
+  },
+  {
+    /* [259] */
+    /* num parameters */ 2,
+    /* num template types */ 0,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[740],
+    /* return matcher indices */ &kMatcherIndices[37],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpOr,
+  },
+  {
+    /* [260] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[29],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[742],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpOr,
+  },
+  {
+    /* [261] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[29],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[744],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpOr,
+  },
+  {
+    /* [262] */
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[468],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::mix,
+  },
+  {
+    /* [263] */
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[471],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::mix,
+  },
+  {
+    /* [264] */
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[474],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::mix,
+  },
+  {
+    /* [265] */
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[27],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[480],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::select_bool,
+  },
+  {
+    /* [266] */
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[27],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[483],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::select_bool,
   },
   {
     /* [267] */
-    /* num parameters */ 1,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[953],
-    /* return matcher indices */ &kMatcherIndices[9],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* num parameters */ 3,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[27],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[486],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::select_boolvec,
   },
   {
     /* [268] */
-    /* num parameters */ 1,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[31],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[954],
-    /* return matcher indices */ &kMatcherIndices[9],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
-  },
-  {
-    /* [269] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[105],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[9],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [270] */
+    /* [269] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[955],
-    /* return matcher indices */ &kMatcherIndices[105],
+    /* return matcher indices */ &kMatcherIndices[9],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [271] */
+    /* [270] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[32],
+    /* template types */ &kTemplateTypes[31],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[956],
-    /* return matcher indices */ &kMatcherIndices[105],
+    /* return matcher indices */ &kMatcherIndices[9],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [272] */
+    /* [271] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[42],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [273] */
+    /* [272] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[957],
-    /* return matcher indices */ &kMatcherIndices[42],
+    /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [274] */
+    /* [273] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[33],
+    /* template types */ &kTemplateTypes[32],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[958],
-    /* return matcher indices */ &kMatcherIndices[42],
+    /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [275] */
+    /* [274] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[1],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[42],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [276] */
+    /* [275] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[959],
-    /* return matcher indices */ &kMatcherIndices[1],
+    /* return matcher indices */ &kMatcherIndices[42],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [277] */
+    /* [276] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[34],
+    /* template types */ &kTemplateTypes[33],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[960],
-    /* return matcher indices */ &kMatcherIndices[1],
+    /* return matcher indices */ &kMatcherIndices[42],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [278] */
+    /* [277] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[39],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[1],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [279] */
+    /* [278] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[961],
+    /* return matcher indices */ &kMatcherIndices[1],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
+  },
+  {
+    /* [279] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[34],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[962],
+    /* return matcher indices */ &kMatcherIndices[1],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
+  },
+  {
+    /* [280] */
+    /* num parameters */ 0,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[39],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Zero,
+  },
+  {
+    /* [281] */
+    /* num parameters */ 1,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[963],
     /* return matcher indices */ &kMatcherIndices[39],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [280] */
+    /* [282] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[35],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[962],
+    /* parameters */ &kParameters[964],
     /* return matcher indices */ &kMatcherIndices[39],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [281] */
+    /* [283] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11784,7 +11818,7 @@
     /* const eval */ &ConstEval::abs,
   },
   {
-    /* [282] */
+    /* [284] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11796,7 +11830,7 @@
     /* const eval */ &ConstEval::abs,
   },
   {
-    /* [283] */
+    /* [285] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11808,7 +11842,7 @@
     /* const eval */ &ConstEval::acos,
   },
   {
-    /* [284] */
+    /* [286] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11820,7 +11854,7 @@
     /* const eval */ &ConstEval::acos,
   },
   {
-    /* [285] */
+    /* [287] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11832,7 +11866,7 @@
     /* const eval */ &ConstEval::acosh,
   },
   {
-    /* [286] */
+    /* [288] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11844,7 +11878,7 @@
     /* const eval */ &ConstEval::acosh,
   },
   {
-    /* [287] */
+    /* [289] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11856,7 +11890,7 @@
     /* const eval */ &ConstEval::all,
   },
   {
-    /* [288] */
+    /* [290] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11868,7 +11902,7 @@
     /* const eval */ &ConstEval::all,
   },
   {
-    /* [289] */
+    /* [291] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11880,7 +11914,7 @@
     /* const eval */ &ConstEval::any,
   },
   {
-    /* [290] */
+    /* [292] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11892,7 +11926,7 @@
     /* const eval */ &ConstEval::any,
   },
   {
-    /* [291] */
+    /* [293] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11904,7 +11938,7 @@
     /* const eval */ &ConstEval::asin,
   },
   {
-    /* [292] */
+    /* [294] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11916,7 +11950,7 @@
     /* const eval */ &ConstEval::asin,
   },
   {
-    /* [293] */
+    /* [295] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11928,7 +11962,7 @@
     /* const eval */ &ConstEval::asinh,
   },
   {
-    /* [294] */
+    /* [296] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11940,7 +11974,7 @@
     /* const eval */ &ConstEval::asinh,
   },
   {
-    /* [295] */
+    /* [297] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11952,7 +11986,7 @@
     /* const eval */ &ConstEval::atan,
   },
   {
-    /* [296] */
+    /* [298] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11964,7 +11998,7 @@
     /* const eval */ &ConstEval::atan,
   },
   {
-    /* [297] */
+    /* [299] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11976,7 +12010,7 @@
     /* const eval */ &ConstEval::atan2,
   },
   {
-    /* [298] */
+    /* [300] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11988,7 +12022,7 @@
     /* const eval */ &ConstEval::atan2,
   },
   {
-    /* [299] */
+    /* [301] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12000,7 +12034,7 @@
     /* const eval */ &ConstEval::atanh,
   },
   {
-    /* [300] */
+    /* [302] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12012,7 +12046,7 @@
     /* const eval */ &ConstEval::atanh,
   },
   {
-    /* [301] */
+    /* [303] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12024,7 +12058,7 @@
     /* const eval */ &ConstEval::ceil,
   },
   {
-    /* [302] */
+    /* [304] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12036,7 +12070,7 @@
     /* const eval */ &ConstEval::ceil,
   },
   {
-    /* [303] */
+    /* [305] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12048,7 +12082,7 @@
     /* const eval */ &ConstEval::clamp,
   },
   {
-    /* [304] */
+    /* [306] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12060,7 +12094,7 @@
     /* const eval */ &ConstEval::clamp,
   },
   {
-    /* [305] */
+    /* [307] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12072,7 +12106,7 @@
     /* const eval */ &ConstEval::cos,
   },
   {
-    /* [306] */
+    /* [308] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12084,7 +12118,7 @@
     /* const eval */ &ConstEval::cos,
   },
   {
-    /* [307] */
+    /* [309] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12096,7 +12130,7 @@
     /* const eval */ &ConstEval::cosh,
   },
   {
-    /* [308] */
+    /* [310] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12108,7 +12142,7 @@
     /* const eval */ &ConstEval::cosh,
   },
   {
-    /* [309] */
+    /* [311] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12120,7 +12154,7 @@
     /* const eval */ &ConstEval::countLeadingZeros,
   },
   {
-    /* [310] */
+    /* [312] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12132,7 +12166,7 @@
     /* const eval */ &ConstEval::countLeadingZeros,
   },
   {
-    /* [311] */
+    /* [313] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12144,7 +12178,7 @@
     /* const eval */ &ConstEval::countOneBits,
   },
   {
-    /* [312] */
+    /* [314] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12156,7 +12190,7 @@
     /* const eval */ &ConstEval::countOneBits,
   },
   {
-    /* [313] */
+    /* [315] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12168,7 +12202,7 @@
     /* const eval */ &ConstEval::countTrailingZeros,
   },
   {
-    /* [314] */
+    /* [316] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12180,7 +12214,7 @@
     /* const eval */ &ConstEval::countTrailingZeros,
   },
   {
-    /* [315] */
+    /* [317] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12192,7 +12226,7 @@
     /* const eval */ &ConstEval::degrees,
   },
   {
-    /* [316] */
+    /* [318] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12204,7 +12238,7 @@
     /* const eval */ &ConstEval::degrees,
   },
   {
-    /* [317] */
+    /* [319] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12216,7 +12250,7 @@
     /* const eval */ &ConstEval::distance,
   },
   {
-    /* [318] */
+    /* [320] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12228,7 +12262,7 @@
     /* const eval */ &ConstEval::distance,
   },
   {
-    /* [319] */
+    /* [321] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12240,7 +12274,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [320] */
+    /* [322] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12252,7 +12286,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [321] */
+    /* [323] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12264,7 +12298,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [322] */
+    /* [324] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12276,7 +12310,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [323] */
+    /* [325] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12288,7 +12322,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [324] */
+    /* [326] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12300,7 +12334,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [325] */
+    /* [327] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12312,7 +12346,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [326] */
+    /* [328] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12324,7 +12358,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [327] */
+    /* [329] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12336,7 +12370,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [328] */
+    /* [330] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12348,7 +12382,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [329] */
+    /* [331] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12360,7 +12394,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [330] */
+    /* [332] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12372,7 +12406,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [331] */
+    /* [333] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12384,7 +12418,7 @@
     /* const eval */ &ConstEval::exp,
   },
   {
-    /* [332] */
+    /* [334] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12396,7 +12430,7 @@
     /* const eval */ &ConstEval::exp,
   },
   {
-    /* [333] */
+    /* [335] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12408,7 +12442,7 @@
     /* const eval */ &ConstEval::exp2,
   },
   {
-    /* [334] */
+    /* [336] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12420,7 +12454,7 @@
     /* const eval */ &ConstEval::exp2,
   },
   {
-    /* [335] */
+    /* [337] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12432,7 +12466,7 @@
     /* const eval */ &ConstEval::extractBits,
   },
   {
-    /* [336] */
+    /* [338] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12444,7 +12478,7 @@
     /* const eval */ &ConstEval::extractBits,
   },
   {
-    /* [337] */
+    /* [339] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12456,7 +12490,7 @@
     /* const eval */ &ConstEval::firstLeadingBit,
   },
   {
-    /* [338] */
+    /* [340] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12468,7 +12502,7 @@
     /* const eval */ &ConstEval::firstLeadingBit,
   },
   {
-    /* [339] */
+    /* [341] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12480,7 +12514,7 @@
     /* const eval */ &ConstEval::firstTrailingBit,
   },
   {
-    /* [340] */
+    /* [342] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12492,7 +12526,7 @@
     /* const eval */ &ConstEval::firstTrailingBit,
   },
   {
-    /* [341] */
+    /* [343] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12504,7 +12538,7 @@
     /* const eval */ &ConstEval::floor,
   },
   {
-    /* [342] */
+    /* [344] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12516,7 +12550,7 @@
     /* const eval */ &ConstEval::floor,
   },
   {
-    /* [343] */
+    /* [345] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12528,7 +12562,7 @@
     /* const eval */ &ConstEval::fma,
   },
   {
-    /* [344] */
+    /* [346] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12540,7 +12574,7 @@
     /* const eval */ &ConstEval::fma,
   },
   {
-    /* [345] */
+    /* [347] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12552,7 +12586,7 @@
     /* const eval */ &ConstEval::fract,
   },
   {
-    /* [346] */
+    /* [348] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12564,7 +12598,7 @@
     /* const eval */ &ConstEval::fract,
   },
   {
-    /* [347] */
+    /* [349] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12576,7 +12610,7 @@
     /* const eval */ &ConstEval::frexp,
   },
   {
-    /* [348] */
+    /* [350] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12588,7 +12622,7 @@
     /* const eval */ &ConstEval::frexp,
   },
   {
-    /* [349] */
+    /* [351] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12600,7 +12634,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [350] */
+    /* [352] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12612,7 +12646,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [351] */
+    /* [353] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12624,7 +12658,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [352] */
+    /* [354] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12636,7 +12670,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [353] */
+    /* [355] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12648,7 +12682,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [354] */
+    /* [356] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12660,7 +12694,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [355] */
+    /* [357] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12672,7 +12706,7 @@
     /* const eval */ &ConstEval::insertBits,
   },
   {
-    /* [356] */
+    /* [358] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12684,7 +12718,7 @@
     /* const eval */ &ConstEval::insertBits,
   },
   {
-    /* [357] */
+    /* [359] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12696,7 +12730,7 @@
     /* const eval */ &ConstEval::inverseSqrt,
   },
   {
-    /* [358] */
+    /* [360] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12708,7 +12742,7 @@
     /* const eval */ &ConstEval::inverseSqrt,
   },
   {
-    /* [359] */
+    /* [361] */
     /* num parameters */ 2,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -12720,7 +12754,7 @@
     /* const eval */ &ConstEval::ldexp,
   },
   {
-    /* [360] */
+    /* [362] */
     /* num parameters */ 2,
     /* num template types */ 2,
     /* num template numbers */ 1,
@@ -12732,7 +12766,7 @@
     /* const eval */ &ConstEval::ldexp,
   },
   {
-    /* [361] */
+    /* [363] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12744,7 +12778,7 @@
     /* const eval */ &ConstEval::length,
   },
   {
-    /* [362] */
+    /* [364] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12756,7 +12790,7 @@
     /* const eval */ &ConstEval::length,
   },
   {
-    /* [363] */
+    /* [365] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12768,7 +12802,7 @@
     /* const eval */ &ConstEval::log,
   },
   {
-    /* [364] */
+    /* [366] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12780,7 +12814,7 @@
     /* const eval */ &ConstEval::log,
   },
   {
-    /* [365] */
+    /* [367] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12792,7 +12826,7 @@
     /* const eval */ &ConstEval::log2,
   },
   {
-    /* [366] */
+    /* [368] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12804,7 +12838,7 @@
     /* const eval */ &ConstEval::log2,
   },
   {
-    /* [367] */
+    /* [369] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12816,7 +12850,7 @@
     /* const eval */ &ConstEval::max,
   },
   {
-    /* [368] */
+    /* [370] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12828,7 +12862,7 @@
     /* const eval */ &ConstEval::max,
   },
   {
-    /* [369] */
+    /* [371] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12840,7 +12874,7 @@
     /* const eval */ &ConstEval::min,
   },
   {
-    /* [370] */
+    /* [372] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12852,7 +12886,7 @@
     /* const eval */ &ConstEval::min,
   },
   {
-    /* [371] */
+    /* [373] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12864,7 +12898,7 @@
     /* const eval */ &ConstEval::modf,
   },
   {
-    /* [372] */
+    /* [374] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12876,7 +12910,7 @@
     /* const eval */ &ConstEval::modf,
   },
   {
-    /* [373] */
+    /* [375] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12888,7 +12922,7 @@
     /* const eval */ &ConstEval::pow,
   },
   {
-    /* [374] */
+    /* [376] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12900,7 +12934,7 @@
     /* const eval */ &ConstEval::pow,
   },
   {
-    /* [375] */
+    /* [377] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12912,7 +12946,7 @@
     /* const eval */ &ConstEval::quantizeToF16,
   },
   {
-    /* [376] */
+    /* [378] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12924,7 +12958,7 @@
     /* const eval */ &ConstEval::quantizeToF16,
   },
   {
-    /* [377] */
+    /* [379] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12936,7 +12970,7 @@
     /* const eval */ &ConstEval::radians,
   },
   {
-    /* [378] */
+    /* [380] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12948,7 +12982,7 @@
     /* const eval */ &ConstEval::radians,
   },
   {
-    /* [379] */
+    /* [381] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12960,7 +12994,7 @@
     /* const eval */ &ConstEval::reverseBits,
   },
   {
-    /* [380] */
+    /* [382] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12972,7 +13006,7 @@
     /* const eval */ &ConstEval::reverseBits,
   },
   {
-    /* [381] */
+    /* [383] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12984,7 +13018,7 @@
     /* const eval */ &ConstEval::round,
   },
   {
-    /* [382] */
+    /* [384] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12996,7 +13030,7 @@
     /* const eval */ &ConstEval::round,
   },
   {
-    /* [383] */
+    /* [385] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13008,7 +13042,7 @@
     /* const eval */ &ConstEval::saturate,
   },
   {
-    /* [384] */
+    /* [386] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13020,7 +13054,7 @@
     /* const eval */ &ConstEval::saturate,
   },
   {
-    /* [385] */
+    /* [387] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13032,7 +13066,7 @@
     /* const eval */ &ConstEval::sign,
   },
   {
-    /* [386] */
+    /* [388] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13044,7 +13078,7 @@
     /* const eval */ &ConstEval::sign,
   },
   {
-    /* [387] */
+    /* [389] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13056,7 +13090,7 @@
     /* const eval */ &ConstEval::sin,
   },
   {
-    /* [388] */
+    /* [390] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13068,7 +13102,7 @@
     /* const eval */ &ConstEval::sin,
   },
   {
-    /* [389] */
+    /* [391] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13080,7 +13114,7 @@
     /* const eval */ &ConstEval::sinh,
   },
   {
-    /* [390] */
+    /* [392] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13092,7 +13126,7 @@
     /* const eval */ &ConstEval::sinh,
   },
   {
-    /* [391] */
+    /* [393] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13104,7 +13138,7 @@
     /* const eval */ &ConstEval::smoothstep,
   },
   {
-    /* [392] */
+    /* [394] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13116,7 +13150,7 @@
     /* const eval */ &ConstEval::smoothstep,
   },
   {
-    /* [393] */
+    /* [395] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13128,7 +13162,7 @@
     /* const eval */ &ConstEval::sqrt,
   },
   {
-    /* [394] */
+    /* [396] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13140,7 +13174,7 @@
     /* const eval */ &ConstEval::sqrt,
   },
   {
-    /* [395] */
+    /* [397] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13152,7 +13186,7 @@
     /* const eval */ &ConstEval::step,
   },
   {
-    /* [396] */
+    /* [398] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13164,7 +13198,7 @@
     /* const eval */ &ConstEval::step,
   },
   {
-    /* [397] */
+    /* [399] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13176,7 +13210,7 @@
     /* const eval */ &ConstEval::tan,
   },
   {
-    /* [398] */
+    /* [400] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13188,7 +13222,7 @@
     /* const eval */ &ConstEval::tan,
   },
   {
-    /* [399] */
+    /* [401] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13200,7 +13234,7 @@
     /* const eval */ &ConstEval::tanh,
   },
   {
-    /* [400] */
+    /* [402] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13212,7 +13246,7 @@
     /* const eval */ &ConstEval::tanh,
   },
   {
-    /* [401] */
+    /* [403] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13224,7 +13258,7 @@
     /* const eval */ &ConstEval::trunc,
   },
   {
-    /* [402] */
+    /* [404] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13236,31 +13270,31 @@
     /* const eval */ &ConstEval::trunc,
   },
   {
-    /* [403] */
+    /* [405] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[0],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[943],
+    /* parameters */ &kParameters[945],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
   },
   {
-    /* [404] */
+    /* [406] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[944],
+    /* parameters */ &kParameters[946],
     /* return matcher indices */ &kMatcherIndices[105],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ nullptr,
   },
   {
-    /* [405] */
+    /* [407] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13272,7 +13306,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [406] */
+    /* [408] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13284,79 +13318,79 @@
     /* const eval */ nullptr,
   },
   {
-    /* [407] */
+    /* [409] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[947],
+    /* parameters */ &kParameters[949],
     /* return matcher indices */ &kMatcherIndices[39],
     /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::OpNot,
   },
   {
-    /* [408] */
+    /* [410] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[948],
+    /* parameters */ &kParameters[950],
     /* return matcher indices */ &kMatcherIndices[37],
     /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::OpNot,
   },
   {
-    /* [409] */
-    /* num parameters */ 1,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[949],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpComplement,
-  },
-  {
-    /* [410] */
-    /* num parameters */ 1,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[29],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[950],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpComplement,
-  },
-  {
     /* [411] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[28],
+    /* template types */ &kTemplateTypes[29],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[951],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpUnaryMinus,
+    /* const eval */ &ConstEval::OpComplement,
   },
   {
     /* [412] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[28],
+    /* template types */ &kTemplateTypes[29],
     /* template numbers */ &kTemplateNumbers[4],
     /* parameters */ &kParameters[952],
     /* return matcher indices */ &kMatcherIndices[34],
     /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpComplement,
+  },
+  {
+    /* [413] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[28],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[953],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpUnaryMinus,
+  },
+  {
+    /* [414] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[28],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[954],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::OpUnaryMinus,
   },
   {
-    /* [413] */
+    /* [415] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13368,7 +13402,7 @@
     /* const eval */ &ConstEval::OpXor,
   },
   {
-    /* [414] */
+    /* [416] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13380,7 +13414,7 @@
     /* const eval */ &ConstEval::OpXor,
   },
   {
-    /* [415] */
+    /* [417] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13392,7 +13426,7 @@
     /* const eval */ &ConstEval::OpEqual,
   },
   {
-    /* [416] */
+    /* [418] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13404,7 +13438,7 @@
     /* const eval */ &ConstEval::OpEqual,
   },
   {
-    /* [417] */
+    /* [419] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13416,7 +13450,7 @@
     /* const eval */ &ConstEval::OpNotEqual,
   },
   {
-    /* [418] */
+    /* [420] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13428,7 +13462,7 @@
     /* const eval */ &ConstEval::OpNotEqual,
   },
   {
-    /* [419] */
+    /* [421] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13440,7 +13474,7 @@
     /* const eval */ &ConstEval::OpLessThan,
   },
   {
-    /* [420] */
+    /* [422] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13452,7 +13486,7 @@
     /* const eval */ &ConstEval::OpLessThan,
   },
   {
-    /* [421] */
+    /* [423] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13464,7 +13498,7 @@
     /* const eval */ &ConstEval::OpGreaterThan,
   },
   {
-    /* [422] */
+    /* [424] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13476,7 +13510,7 @@
     /* const eval */ &ConstEval::OpGreaterThan,
   },
   {
-    /* [423] */
+    /* [425] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13488,7 +13522,7 @@
     /* const eval */ &ConstEval::OpLessThanEqual,
   },
   {
-    /* [424] */
+    /* [426] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13500,7 +13534,7 @@
     /* const eval */ &ConstEval::OpLessThanEqual,
   },
   {
-    /* [425] */
+    /* [427] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13512,7 +13546,7 @@
     /* const eval */ &ConstEval::OpGreaterThanEqual,
   },
   {
-    /* [426] */
+    /* [428] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13524,7 +13558,7 @@
     /* const eval */ &ConstEval::OpGreaterThanEqual,
   },
   {
-    /* [427] */
+    /* [429] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13536,7 +13570,7 @@
     /* const eval */ &ConstEval::OpShiftLeft,
   },
   {
-    /* [428] */
+    /* [430] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13548,7 +13582,7 @@
     /* const eval */ &ConstEval::OpShiftLeft,
   },
   {
-    /* [429] */
+    /* [431] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13560,7 +13594,7 @@
     /* const eval */ &ConstEval::OpShiftRight,
   },
   {
-    /* [430] */
+    /* [432] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13572,7 +13606,7 @@
     /* const eval */ &ConstEval::OpShiftRight,
   },
   {
-    /* [431] */
+    /* [433] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13584,7 +13618,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [432] */
+    /* [434] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13596,7 +13630,7 @@
     /* const eval */ &ConstEval::cross,
   },
   {
-    /* [433] */
+    /* [435] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13608,7 +13642,7 @@
     /* const eval */ &ConstEval::determinant,
   },
   {
-    /* [434] */
+    /* [436] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13620,7 +13654,7 @@
     /* const eval */ &ConstEval::dot,
   },
   {
-    /* [435] */
+    /* [437] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13632,7 +13666,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [436] */
+    /* [438] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13644,7 +13678,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [437] */
+    /* [439] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13656,7 +13690,7 @@
     /* const eval */ &ConstEval::faceForward,
   },
   {
-    /* [438] */
+    /* [440] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13668,7 +13702,7 @@
     /* const eval */ &ConstEval::normalize,
   },
   {
-    /* [439] */
+    /* [441] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13680,7 +13714,7 @@
     /* const eval */ &ConstEval::pack2x16float,
   },
   {
-    /* [440] */
+    /* [442] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13692,7 +13726,7 @@
     /* const eval */ &ConstEval::pack2x16snorm,
   },
   {
-    /* [441] */
+    /* [443] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13704,7 +13738,7 @@
     /* const eval */ &ConstEval::pack2x16unorm,
   },
   {
-    /* [442] */
+    /* [444] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13716,7 +13750,7 @@
     /* const eval */ &ConstEval::pack4x8snorm,
   },
   {
-    /* [443] */
+    /* [445] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13728,7 +13762,7 @@
     /* const eval */ &ConstEval::pack4x8unorm,
   },
   {
-    /* [444] */
+    /* [446] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13740,7 +13774,7 @@
     /* const eval */ &ConstEval::reflect,
   },
   {
-    /* [445] */
+    /* [447] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13752,19 +13786,19 @@
     /* const eval */ &ConstEval::refract,
   },
   {
-    /* [446] */
+    /* [448] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ nullptr,
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
   },
   {
-    /* [447] */
+    /* [449] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 2,
@@ -13776,7 +13810,7 @@
     /* const eval */ &ConstEval::transpose,
   },
   {
-    /* [448] */
+    /* [450] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13788,7 +13822,7 @@
     /* const eval */ &ConstEval::unpack2x16float,
   },
   {
-    /* [449] */
+    /* [451] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13800,7 +13834,7 @@
     /* const eval */ &ConstEval::unpack2x16snorm,
   },
   {
-    /* [450] */
+    /* [452] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13812,7 +13846,7 @@
     /* const eval */ &ConstEval::unpack2x16unorm,
   },
   {
-    /* [451] */
+    /* [453] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13824,7 +13858,7 @@
     /* const eval */ &ConstEval::unpack4x8snorm,
   },
   {
-    /* [452] */
+    /* [454] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13836,19 +13870,19 @@
     /* const eval */ &ConstEval::unpack4x8unorm,
   },
   {
-    /* [453] */
+    /* [455] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1012],
+    /* parameters */ &kParameters[1014],
     /* return matcher indices */ nullptr,
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
   },
   {
-    /* [454] */
+    /* [456] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13860,37 +13894,13 @@
     /* const eval */ nullptr,
   },
   {
-    /* [455] */
+    /* [457] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[945],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [456] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[26],
-    /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[654],
-    /* return matcher indices */ nullptr,
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [457] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[26],
-    /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[656],
+    /* parameters */ &kParameters[947],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13902,8 +13912,8 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[658],
-    /* return matcher indices */ &kMatcherIndices[3],
+    /* parameters */ &kParameters[654],
+    /* return matcher indices */ nullptr,
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
   },
@@ -13914,7 +13924,7 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[660],
+    /* parameters */ &kParameters[656],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13926,7 +13936,7 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[662],
+    /* parameters */ &kParameters[658],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13938,7 +13948,7 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[664],
+    /* parameters */ &kParameters[660],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13950,7 +13960,7 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[666],
+    /* parameters */ &kParameters[662],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13962,7 +13972,7 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[668],
+    /* parameters */ &kParameters[664],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
@@ -13974,13 +13984,37 @@
     /* num template numbers */ 1,
     /* template types */ &kTemplateTypes[26],
     /* template numbers */ &kTemplateNumbers[9],
-    /* parameters */ &kParameters[670],
+    /* parameters */ &kParameters[666],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ nullptr,
   },
   {
     /* [465] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[26],
+    /* template numbers */ &kTemplateNumbers[9],
+    /* parameters */ &kParameters[668],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [466] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[26],
+    /* template numbers */ &kTemplateNumbers[9],
+    /* parameters */ &kParameters[670],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [467] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13992,19 +14026,19 @@
     /* const eval */ nullptr,
   },
   {
-    /* [466] */
+    /* [468] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[25],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[946],
+    /* parameters */ &kParameters[948],
     /* return matcher indices */ &kMatcherIndices[3],
     /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [467] */
+    /* [469] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -14016,7 +14050,7 @@
     /* const eval */ &ConstEval::OpLogicalAnd,
   },
   {
-    /* [468] */
+    /* [470] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -14028,13 +14062,13 @@
     /* const eval */ &ConstEval::OpLogicalOr,
   },
   {
-    /* [469] */
+    /* [471] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[36],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1011],
+    /* parameters */ &kParameters[1013],
     /* return matcher indices */ &kMatcherIndices[232],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
@@ -14047,357 +14081,357 @@
     /* fn abs<T : fia_fiu32_f16>(T) -> T */
     /* fn abs<N : num, T : fia_fiu32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[281],
+    /* overloads */ &kOverloads[283],
   },
   {
     /* [1] */
     /* fn acos<T : fa_f32_f16>(@test_value(0.96891242171) T) -> T */
     /* fn acos<N : num, T : fa_f32_f16>(@test_value(0.96891242171) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[283],
+    /* overloads */ &kOverloads[285],
   },
   {
     /* [2] */
     /* fn acosh<T : fa_f32_f16>(@test_value(1.5430806348) T) -> T */
     /* fn acosh<N : num, T : fa_f32_f16>(@test_value(1.5430806348) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[285],
+    /* overloads */ &kOverloads[287],
   },
   {
     /* [3] */
     /* fn all(bool) -> bool */
     /* fn all<N : num>(vec<N, bool>) -> bool */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[287],
+    /* overloads */ &kOverloads[289],
   },
   {
     /* [4] */
     /* fn any(bool) -> bool */
     /* fn any<N : num>(vec<N, bool>) -> bool */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[289],
+    /* overloads */ &kOverloads[291],
   },
   {
     /* [5] */
     /* fn arrayLength<T, A : access>(ptr<storage, array<T>, A>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[431],
+    /* overloads */ &kOverloads[433],
   },
   {
     /* [6] */
     /* fn asin<T : fa_f32_f16>(@test_value(0.479425538604) T) -> T */
     /* fn asin<N : num, T : fa_f32_f16>(@test_value(0.479425538604) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[291],
+    /* overloads */ &kOverloads[293],
   },
   {
     /* [7] */
     /* fn asinh<T : fa_f32_f16>(T) -> T */
     /* fn asinh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[293],
+    /* overloads */ &kOverloads[295],
   },
   {
     /* [8] */
     /* fn atan<T : fa_f32_f16>(T) -> T */
     /* fn atan<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[295],
+    /* overloads */ &kOverloads[297],
   },
   {
     /* [9] */
     /* fn atan2<T : fa_f32_f16>(T, T) -> T */
     /* fn atan2<T : fa_f32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[297],
+    /* overloads */ &kOverloads[299],
   },
   {
     /* [10] */
     /* fn atanh<T : fa_f32_f16>(@test_value(0.5) T) -> T */
     /* fn atanh<N : num, T : fa_f32_f16>(@test_value(0.5) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[299],
+    /* overloads */ &kOverloads[301],
   },
   {
     /* [11] */
     /* fn ceil<T : fa_f32_f16>(@test_value(1.5) T) -> T */
     /* fn ceil<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[301],
+    /* overloads */ &kOverloads[303],
   },
   {
     /* [12] */
     /* fn clamp<T : fia_fiu32_f16>(T, T, T) -> T */
     /* fn clamp<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[303],
+    /* overloads */ &kOverloads[305],
   },
   {
     /* [13] */
     /* fn cos<T : fa_f32_f16>(@test_value(0) T) -> T */
     /* fn cos<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[305],
+    /* overloads */ &kOverloads[307],
   },
   {
     /* [14] */
     /* fn cosh<T : fa_f32_f16>(@test_value(0) T) -> T */
     /* fn cosh<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[307],
+    /* overloads */ &kOverloads[309],
   },
   {
     /* [15] */
     /* fn countLeadingZeros<T : iu32>(T) -> T */
     /* fn countLeadingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[309],
+    /* overloads */ &kOverloads[311],
   },
   {
     /* [16] */
     /* fn countOneBits<T : iu32>(T) -> T */
     /* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[311],
+    /* overloads */ &kOverloads[313],
   },
   {
     /* [17] */
     /* fn countTrailingZeros<T : iu32>(T) -> T */
     /* fn countTrailingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[313],
+    /* overloads */ &kOverloads[315],
   },
   {
     /* [18] */
     /* fn cross<T : fa_f32_f16>(vec3<T>, vec3<T>) -> vec3<T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[432],
+    /* overloads */ &kOverloads[434],
   },
   {
     /* [19] */
     /* fn degrees<T : fa_f32_f16>(T) -> T */
     /* fn degrees<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[315],
+    /* overloads */ &kOverloads[317],
   },
   {
     /* [20] */
     /* fn determinant<N : num, T : fa_f32_f16>(mat<N, N, T>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[433],
+    /* overloads */ &kOverloads[435],
   },
   {
     /* [21] */
     /* fn distance<T : fa_f32_f16>(T, T) -> T */
     /* fn distance<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> T */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[317],
+    /* overloads */ &kOverloads[319],
   },
   {
     /* [22] */
     /* fn dot<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[434],
+    /* overloads */ &kOverloads[436],
   },
   {
     /* [23] */
     /* fn dot4I8Packed(u32, u32) -> i32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[435],
+    /* overloads */ &kOverloads[437],
   },
   {
     /* [24] */
     /* fn dot4U8Packed(u32, u32) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[436],
+    /* overloads */ &kOverloads[438],
   },
   {
     /* [25] */
     /* fn dpdx(f32) -> f32 */
     /* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[319],
+    /* overloads */ &kOverloads[321],
   },
   {
     /* [26] */
     /* fn dpdxCoarse(f32) -> f32 */
     /* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[321],
+    /* overloads */ &kOverloads[323],
   },
   {
     /* [27] */
     /* fn dpdxFine(f32) -> f32 */
     /* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[323],
+    /* overloads */ &kOverloads[325],
   },
   {
     /* [28] */
     /* fn dpdy(f32) -> f32 */
     /* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[325],
+    /* overloads */ &kOverloads[327],
   },
   {
     /* [29] */
     /* fn dpdyCoarse(f32) -> f32 */
     /* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[327],
+    /* overloads */ &kOverloads[329],
   },
   {
     /* [30] */
     /* fn dpdyFine(f32) -> f32 */
     /* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[329],
+    /* overloads */ &kOverloads[331],
   },
   {
     /* [31] */
     /* fn exp<T : fa_f32_f16>(T) -> T */
     /* fn exp<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[331],
+    /* overloads */ &kOverloads[333],
   },
   {
     /* [32] */
     /* fn exp2<T : fa_f32_f16>(T) -> T */
     /* fn exp2<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[333],
+    /* overloads */ &kOverloads[335],
   },
   {
     /* [33] */
     /* fn extractBits<T : iu32>(T, u32, u32) -> T */
     /* fn extractBits<N : num, T : iu32>(vec<N, T>, u32, u32) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[335],
+    /* overloads */ &kOverloads[337],
   },
   {
     /* [34] */
     /* fn faceForward<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[437],
+    /* overloads */ &kOverloads[439],
   },
   {
     /* [35] */
     /* fn firstLeadingBit<T : iu32>(T) -> T */
     /* fn firstLeadingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[337],
+    /* overloads */ &kOverloads[339],
   },
   {
     /* [36] */
     /* fn firstTrailingBit<T : iu32>(T) -> T */
     /* fn firstTrailingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[339],
+    /* overloads */ &kOverloads[341],
   },
   {
     /* [37] */
     /* fn floor<T : fa_f32_f16>(@test_value(1.5) T) -> T */
     /* fn floor<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[341],
+    /* overloads */ &kOverloads[343],
   },
   {
     /* [38] */
     /* fn fma<T : fa_f32_f16>(T, T, T) -> T */
     /* fn fma<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[343],
+    /* overloads */ &kOverloads[345],
   },
   {
     /* [39] */
     /* fn fract<T : fa_f32_f16>(@test_value(1.25) T) -> T */
     /* fn fract<N : num, T : fa_f32_f16>(@test_value(1.25) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[345],
+    /* overloads */ &kOverloads[347],
   },
   {
     /* [40] */
     /* fn frexp<T : fa_f32_f16>(T) -> __frexp_result<T> */
     /* fn frexp<N : num, T : fa_f32_f16>(vec<N, T>) -> __frexp_result_vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[347],
+    /* overloads */ &kOverloads[349],
   },
   {
     /* [41] */
     /* fn fwidth(f32) -> f32 */
     /* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[349],
+    /* overloads */ &kOverloads[351],
   },
   {
     /* [42] */
     /* fn fwidthCoarse(f32) -> f32 */
     /* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[351],
+    /* overloads */ &kOverloads[353],
   },
   {
     /* [43] */
     /* fn fwidthFine(f32) -> f32 */
     /* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[353],
+    /* overloads */ &kOverloads[355],
   },
   {
     /* [44] */
     /* fn insertBits<T : iu32>(T, T, u32, u32) -> T */
     /* fn insertBits<N : num, T : iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[355],
+    /* overloads */ &kOverloads[357],
   },
   {
     /* [45] */
     /* fn inverseSqrt<T : fa_f32_f16>(T) -> T */
     /* fn inverseSqrt<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[357],
+    /* overloads */ &kOverloads[359],
   },
   {
     /* [46] */
     /* fn ldexp<T : fa_f32_f16, U : ia_i32>(T, U) -> T */
     /* fn ldexp<N : num, T : fa_f32_f16, U : ia_i32>(vec<N, T>, vec<N, U>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[359],
+    /* overloads */ &kOverloads[361],
   },
   {
     /* [47] */
     /* fn length<T : fa_f32_f16>(@test_value(0) T) -> T */
     /* fn length<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> T */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[361],
+    /* overloads */ &kOverloads[363],
   },
   {
     /* [48] */
     /* fn log<T : fa_f32_f16>(T) -> T */
     /* fn log<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[363],
+    /* overloads */ &kOverloads[365],
   },
   {
     /* [49] */
     /* fn log2<T : fa_f32_f16>(T) -> T */
     /* fn log2<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[365],
+    /* overloads */ &kOverloads[367],
   },
   {
     /* [50] */
     /* fn max<T : fia_fiu32_f16>(T, T) -> T */
     /* fn max<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[367],
+    /* overloads */ &kOverloads[369],
   },
   {
     /* [51] */
     /* fn min<T : fia_fiu32_f16>(T, T) -> T */
     /* fn min<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[369],
+    /* overloads */ &kOverloads[371],
   },
   {
     /* [52] */
@@ -14405,104 +14439,104 @@
     /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[257],
+    /* overloads */ &kOverloads[262],
   },
   {
     /* [53] */
     /* fn modf<T : fa_f32_f16>(@test_value(-1.5) T) -> __modf_result<T> */
     /* fn modf<N : num, T : fa_f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[371],
+    /* overloads */ &kOverloads[373],
   },
   {
     /* [54] */
     /* fn normalize<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[438],
+    /* overloads */ &kOverloads[440],
   },
   {
     /* [55] */
     /* fn pack2x16float(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[439],
+    /* overloads */ &kOverloads[441],
   },
   {
     /* [56] */
     /* fn pack2x16snorm(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[440],
+    /* overloads */ &kOverloads[442],
   },
   {
     /* [57] */
     /* fn pack2x16unorm(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[441],
+    /* overloads */ &kOverloads[443],
   },
   {
     /* [58] */
     /* fn pack4x8snorm(vec4<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[442],
+    /* overloads */ &kOverloads[444],
   },
   {
     /* [59] */
     /* fn pack4x8unorm(vec4<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[443],
+    /* overloads */ &kOverloads[445],
   },
   {
     /* [60] */
     /* fn pow<T : fa_f32_f16>(T, T) -> T */
     /* fn pow<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[373],
+    /* overloads */ &kOverloads[375],
   },
   {
     /* [61] */
     /* fn quantizeToF16(f32) -> f32 */
     /* fn quantizeToF16<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[375],
+    /* overloads */ &kOverloads[377],
   },
   {
     /* [62] */
     /* fn radians<T : fa_f32_f16>(T) -> T */
     /* fn radians<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[377],
+    /* overloads */ &kOverloads[379],
   },
   {
     /* [63] */
     /* fn reflect<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[444],
+    /* overloads */ &kOverloads[446],
   },
   {
     /* [64] */
     /* fn refract<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[445],
+    /* overloads */ &kOverloads[447],
   },
   {
     /* [65] */
     /* fn reverseBits<T : iu32>(T) -> T */
     /* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[379],
+    /* overloads */ &kOverloads[381],
   },
   {
     /* [66] */
     /* fn round<T : fa_f32_f16>(@test_value(3.5) T) -> T */
     /* fn round<N : num, T : fa_f32_f16>(@test_value(3.5) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[381],
+    /* overloads */ &kOverloads[383],
   },
   {
     /* [67] */
     /* fn saturate<T : fa_f32_f16>(@test_value(2) T) -> T */
     /* fn saturate<T : fa_f32_f16, N : num>(@test_value(2) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[383],
+    /* overloads */ &kOverloads[385],
   },
   {
     /* [68] */
@@ -14510,124 +14544,124 @@
     /* fn select<T : scalar, N : num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T> */
     /* fn select<N : num, T : scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[260],
+    /* overloads */ &kOverloads[265],
   },
   {
     /* [69] */
     /* fn sign<T : fia_fi32_f16>(T) -> T */
     /* fn sign<N : num, T : fia_fi32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[385],
+    /* overloads */ &kOverloads[387],
   },
   {
     /* [70] */
     /* fn sin<T : fa_f32_f16>(@test_value(1.57079632679) T) -> T */
     /* fn sin<N : num, T : fa_f32_f16>(@test_value(1.57079632679) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[387],
+    /* overloads */ &kOverloads[389],
   },
   {
     /* [71] */
     /* fn sinh<T : fa_f32_f16>(T) -> T */
     /* fn sinh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[389],
+    /* overloads */ &kOverloads[391],
   },
   {
     /* [72] */
     /* fn smoothstep<T : fa_f32_f16>(@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T */
     /* fn smoothstep<N : num, T : fa_f32_f16>(@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[391],
+    /* overloads */ &kOverloads[393],
   },
   {
     /* [73] */
     /* fn sqrt<T : fa_f32_f16>(T) -> T */
     /* fn sqrt<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[393],
+    /* overloads */ &kOverloads[395],
   },
   {
     /* [74] */
     /* fn step<T : fa_f32_f16>(T, T) -> T */
     /* fn step<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[395],
+    /* overloads */ &kOverloads[397],
   },
   {
     /* [75] */
     /* fn storageBarrier() */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[446],
+    /* overloads */ &kOverloads[448],
   },
   {
     /* [76] */
     /* fn tan<T : fa_f32_f16>(T) -> T */
     /* fn tan<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[397],
+    /* overloads */ &kOverloads[399],
   },
   {
     /* [77] */
     /* fn tanh<T : fa_f32_f16>(T) -> T */
     /* fn tanh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[399],
+    /* overloads */ &kOverloads[401],
   },
   {
     /* [78] */
     /* fn transpose<M : num, N : num, T : fa_f32_f16>(mat<M, N, T>) -> mat<N, M, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[447],
+    /* overloads */ &kOverloads[449],
   },
   {
     /* [79] */
     /* fn trunc<T : fa_f32_f16>(@test_value(1.5) T) -> T */
     /* fn trunc<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[401],
+    /* overloads */ &kOverloads[403],
   },
   {
     /* [80] */
     /* fn unpack2x16float(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[448],
+    /* overloads */ &kOverloads[450],
   },
   {
     /* [81] */
     /* fn unpack2x16snorm(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[449],
+    /* overloads */ &kOverloads[451],
   },
   {
     /* [82] */
     /* fn unpack2x16unorm(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[450],
+    /* overloads */ &kOverloads[452],
   },
   {
     /* [83] */
     /* fn unpack4x8snorm(u32) -> vec4<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[451],
+    /* overloads */ &kOverloads[453],
   },
   {
     /* [84] */
     /* fn unpack4x8unorm(u32) -> vec4<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[452],
+    /* overloads */ &kOverloads[454],
   },
   {
     /* [85] */
     /* fn workgroupBarrier() */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[453],
+    /* overloads */ &kOverloads[455],
   },
   {
     /* [86] */
     /* fn workgroupUniformLoad<T>(ptr<workgroup, T, read_write>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[454],
+    /* overloads */ &kOverloads[456],
   },
   {
     /* [87] */
@@ -14692,10 +14726,12 @@
   {
     /* [90] */
     /* fn textureNumLayers<T : fiu32>(texture: texture_2d_array<T>) -> u32 */
+    /* fn textureNumLayers<T : fiu32>(texture: texture_cube_array<T>) -> u32 */
     /* fn textureNumLayers(texture: texture_depth_2d_array) -> u32 */
+    /* fn textureNumLayers(texture: texture_depth_cube_array) -> u32 */
     /* fn textureNumLayers<F : texel_format, A : write>(texture: texture_storage_2d_array<F, A>) -> u32 */
-    /* num overloads */ 3,
-    /* overloads */ &kOverloads[263],
+    /* num overloads */ 5,
+    /* overloads */ &kOverloads[231],
   },
   {
     /* [91] */
@@ -14717,7 +14753,7 @@
     /* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> u32 */
     /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[403],
+    /* overloads */ &kOverloads[405],
   },
   {
     /* [93] */
@@ -14811,7 +14847,7 @@
     /* fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
     /* fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[405],
+    /* overloads */ &kOverloads[407],
   },
   {
     /* [100] */
@@ -14848,73 +14884,73 @@
     /* [102] */
     /* fn atomicLoad<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[455],
+    /* overloads */ &kOverloads[457],
   },
   {
     /* [103] */
     /* fn atomicStore<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[456],
+    /* overloads */ &kOverloads[458],
   },
   {
     /* [104] */
     /* fn atomicAdd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[457],
+    /* overloads */ &kOverloads[459],
   },
   {
     /* [105] */
     /* fn atomicSub<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[458],
+    /* overloads */ &kOverloads[460],
   },
   {
     /* [106] */
     /* fn atomicMax<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[459],
+    /* overloads */ &kOverloads[461],
   },
   {
     /* [107] */
     /* fn atomicMin<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[460],
+    /* overloads */ &kOverloads[462],
   },
   {
     /* [108] */
     /* fn atomicAnd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[461],
+    /* overloads */ &kOverloads[463],
   },
   {
     /* [109] */
     /* fn atomicOr<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[462],
+    /* overloads */ &kOverloads[464],
   },
   {
     /* [110] */
     /* fn atomicXor<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[463],
+    /* overloads */ &kOverloads[465],
   },
   {
     /* [111] */
     /* fn atomicExchange<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[464],
+    /* overloads */ &kOverloads[466],
   },
   {
     /* [112] */
     /* fn atomicCompareExchangeWeak<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[465],
+    /* overloads */ &kOverloads[467],
   },
   {
     /* [113] */
     /* fn _tint_materialize<T>(T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[466],
+    /* overloads */ &kOverloads[468],
   },
 };
 
@@ -14924,21 +14960,21 @@
     /* op !(bool) -> bool */
     /* op !<N : num>(vec<N, bool>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[407],
+    /* overloads */ &kOverloads[409],
   },
   {
     /* [1] */
     /* op ~<T : ia_iu32>(T) -> T */
     /* op ~<T : ia_iu32, N : num>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[409],
+    /* overloads */ &kOverloads[411],
   },
   {
     /* [2] */
     /* op -<T : fia_fi32_f16>(T) -> T */
     /* op -<T : fia_fi32_f16, N : num>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[411],
+    /* overloads */ &kOverloads[413],
   },
 };
 constexpr uint8_t kUnaryOperatorNot = 0;
@@ -14954,7 +14990,7 @@
     /* op +<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
     /* op +<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */
     /* num overloads */ 5,
-    /* overloads */ &kOverloads[231],
+    /* overloads */ &kOverloads[236],
   },
   {
     /* [1] */
@@ -14964,7 +15000,7 @@
     /* op -<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
     /* op -<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */
     /* num overloads */ 5,
-    /* overloads */ &kOverloads[236],
+    /* overloads */ &kOverloads[241],
   },
   {
     /* [2] */
@@ -14987,7 +15023,7 @@
     /* op /<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
     /* op /<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 4,
-    /* overloads */ &kOverloads[241],
+    /* overloads */ &kOverloads[246],
   },
   {
     /* [4] */
@@ -14996,14 +15032,14 @@
     /* op %<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
     /* op %<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 4,
-    /* overloads */ &kOverloads[245],
+    /* overloads */ &kOverloads[250],
   },
   {
     /* [5] */
     /* op ^<T : ia_iu32>(T, T) -> T */
     /* op ^<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[413],
+    /* overloads */ &kOverloads[415],
   },
   {
     /* [6] */
@@ -15012,7 +15048,7 @@
     /* op &<T : ia_iu32>(T, T) -> T */
     /* op &<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 4,
-    /* overloads */ &kOverloads[249],
+    /* overloads */ &kOverloads[254],
   },
   {
     /* [7] */
@@ -15021,75 +15057,75 @@
     /* op |<T : ia_iu32>(T, T) -> T */
     /* op |<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 4,
-    /* overloads */ &kOverloads[253],
+    /* overloads */ &kOverloads[258],
   },
   {
     /* [8] */
     /* op &&(bool, bool) -> bool */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[467],
+    /* overloads */ &kOverloads[469],
   },
   {
     /* [9] */
     /* op ||(bool, bool) -> bool */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[468],
+    /* overloads */ &kOverloads[470],
   },
   {
     /* [10] */
     /* op ==<T : scalar>(T, T) -> bool */
     /* op ==<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[415],
+    /* overloads */ &kOverloads[417],
   },
   {
     /* [11] */
     /* op !=<T : scalar>(T, T) -> bool */
     /* op !=<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[417],
+    /* overloads */ &kOverloads[419],
   },
   {
     /* [12] */
     /* op <<T : fia_fiu32_f16>(T, T) -> bool */
     /* op <<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[419],
+    /* overloads */ &kOverloads[421],
   },
   {
     /* [13] */
     /* op ><T : fia_fiu32_f16>(T, T) -> bool */
     /* op ><T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[421],
+    /* overloads */ &kOverloads[423],
   },
   {
     /* [14] */
     /* op <=<T : fia_fiu32_f16>(T, T) -> bool */
     /* op <=<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[423],
+    /* overloads */ &kOverloads[425],
   },
   {
     /* [15] */
     /* op >=<T : fia_fiu32_f16>(T, T) -> bool */
     /* op >=<T : fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[425],
+    /* overloads */ &kOverloads[427],
   },
   {
     /* [16] */
     /* op <<<T : ia_iu32>(T, u32) -> T */
     /* op <<<T : ia_iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[427],
+    /* overloads */ &kOverloads[429],
   },
   {
     /* [17] */
     /* op >><T : ia_iu32>(T, u32) -> T */
     /* op >><T : ia_iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[429],
+    /* overloads */ &kOverloads[431],
   },
 };
 constexpr uint8_t kBinaryOperatorPlus = 0;
@@ -15118,7 +15154,7 @@
     /* ctor i32(i32) -> i32 */
     /* conv i32<T : scalar_no_i32>(T) -> i32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[266],
+    /* overloads */ &kOverloads[268],
   },
   {
     /* [1] */
@@ -15126,7 +15162,7 @@
     /* ctor u32(u32) -> u32 */
     /* conv u32<T : scalar_no_u32>(T) -> u32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[269],
+    /* overloads */ &kOverloads[271],
   },
   {
     /* [2] */
@@ -15134,7 +15170,7 @@
     /* ctor f32(f32) -> f32 */
     /* conv f32<T : scalar_no_f32>(T) -> f32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[272],
+    /* overloads */ &kOverloads[274],
   },
   {
     /* [3] */
@@ -15142,7 +15178,7 @@
     /* ctor f16(f16) -> f16 */
     /* conv f16<T : scalar_no_f16>(T) -> f16 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[275],
+    /* overloads */ &kOverloads[277],
   },
   {
     /* [4] */
@@ -15150,7 +15186,7 @@
     /* ctor bool(bool) -> bool */
     /* conv bool<T : scalar_no_bool>(T) -> bool */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[278],
+    /* overloads */ &kOverloads[280],
   },
   {
     /* [5] */
@@ -15305,7 +15341,7 @@
     /* [17] */
     /* conv packedVec3<T : concrete_scalar>(vec3<T>) -> packedVec3<T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[469],
+    /* overloads */ &kOverloads[471],
   },
 };
 
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index 7f0399d..c842af5 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -37,7 +37,6 @@
 
 using ::testing::HasSubstr;
 
-using BuiltinType = sem::BuiltinType;
 using Parameter = sem::Parameter;
 using ParameterUsage = sem::ParameterUsage;
 
@@ -54,11 +53,11 @@
 
 TEST_F(IntrinsicTableTest, MatchF32) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kCos, utils::Vector{f32},
+    auto result = table->Lookup(builtin::Function::kCos, utils::Vector{f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kCos);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kCos);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -66,7 +65,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchF32) {
     auto* i32 = create<type::I32>();
-    auto result = table->Lookup(BuiltinType::kCos, utils::Vector{i32},
+    auto result = table->Lookup(builtin::Function::kCos, utils::Vector{i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -76,11 +75,11 @@
     auto* f32 = create<type::F32>();
     auto* u32 = create<type::U32>();
     auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto result = table->Lookup(BuiltinType::kUnpack2X16Float, utils::Vector{u32},
+    auto result = table->Lookup(builtin::Function::kUnpack2X16Float, utils::Vector{u32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kUnpack2X16Float);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kUnpack2X16Float);
     EXPECT_EQ(result.sem->ReturnType(), vec2_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -88,7 +87,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchU32) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kUnpack2X16Float, utils::Vector{f32},
+    auto result = table->Lookup(builtin::Function::kUnpack2X16Float, utils::Vector{f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -99,11 +98,11 @@
     auto* i32 = create<type::I32>();
     auto* vec4_f32 = create<type::Vector>(f32, 4u);
     auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, i32, i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -117,7 +116,7 @@
 TEST_F(IntrinsicTableTest, MismatchI32) {
     auto* f32 = create<type::F32>();
     auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, f32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -125,11 +124,11 @@
 
 TEST_F(IntrinsicTableTest, MatchIU32AsI32) {
     auto* i32 = create<type::I32>();
-    auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{i32},
+    auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kCountOneBits);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kCountOneBits);
     EXPECT_EQ(result.sem->ReturnType(), i32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), i32);
@@ -137,11 +136,11 @@
 
 TEST_F(IntrinsicTableTest, MatchIU32AsU32) {
     auto* u32 = create<type::U32>();
-    auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{u32},
+    auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{u32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kCountOneBits);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kCountOneBits);
     EXPECT_EQ(result.sem->ReturnType(), u32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -149,7 +148,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchIU32) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{f32},
+    auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -157,11 +156,11 @@
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsI32) {
     auto* i32 = create<type::I32>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{i32, i32, i32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{i32, i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
     EXPECT_EQ(result.sem->ReturnType(), i32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), i32);
@@ -171,11 +170,11 @@
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsU32) {
     auto* u32 = create<type::U32>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{u32, u32, u32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{u32, u32, u32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
     EXPECT_EQ(result.sem->ReturnType(), u32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -185,11 +184,11 @@
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsF32) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, f32, f32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, f32, f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -199,7 +198,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchFIU32) {
     auto* bool_ = create<type::Bool>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{bool_, bool_, bool_},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{bool_, bool_, bool_},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -208,11 +207,11 @@
 TEST_F(IntrinsicTableTest, MatchBool) {
     auto* f32 = create<type::F32>();
     auto* bool_ = create<type::Bool>();
-    auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+    auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -222,7 +221,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchBool) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, f32},
+    auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -233,11 +232,11 @@
     auto* atomicI32 = create<type::Atomic>(i32);
     auto* ptr = create<type::Pointer>(atomicI32, builtin::AddressSpace::kWorkgroup,
                                       builtin::Access::kReadWrite);
-    auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr},
+    auto result = table->Lookup(builtin::Function::kAtomicLoad, utils::Vector{ptr},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kAtomicLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kAtomicLoad);
     EXPECT_EQ(result.sem->ReturnType(), i32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), ptr);
@@ -246,7 +245,7 @@
 TEST_F(IntrinsicTableTest, MismatchPointer) {
     auto* i32 = create<type::I32>();
     auto* atomicI32 = create<type::Atomic>(i32);
-    auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{atomicI32},
+    auto result = table->Lookup(builtin::Function::kAtomicLoad, utils::Vector{atomicI32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -257,11 +256,11 @@
         create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
     auto* arr_ptr =
         create<type::Pointer>(arr, builtin::AddressSpace::kStorage, builtin::Access::kReadWrite);
-    auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr},
+    auto result = table->Lookup(builtin::Function::kArrayLength, utils::Vector{arr_ptr},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kArrayLength);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kArrayLength);
     EXPECT_TRUE(result.sem->ReturnType()->Is<type::U32>());
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     auto* param_type = result.sem->Parameters()[0]->Type();
@@ -271,7 +270,7 @@
 
 TEST_F(IntrinsicTableTest, MismatchArray) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{f32},
+    auto result = table->Lookup(builtin::Function::kArrayLength, utils::Vector{f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -283,11 +282,12 @@
     auto* vec4_f32 = create<type::Vector>(f32, 4u);
     auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
     auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
-    auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, sampler, vec2_f32},
-                                sem::EvaluationStage::kConstant, Source{});
+    auto result =
+        table->Lookup(builtin::Function::kTextureSample, utils::Vector{tex, sampler, vec2_f32},
+                      sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureSample);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureSample);
     EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -302,8 +302,9 @@
     auto* f32 = create<type::F32>();
     auto* vec2_f32 = create<type::Vector>(f32, 2u);
     auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
-    auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, f32, vec2_f32},
-                                sem::EvaluationStage::kConstant, Source{});
+    auto result =
+        table->Lookup(builtin::Function::kTextureSample, utils::Vector{tex, f32, vec2_f32},
+                      sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
 }
@@ -314,11 +315,11 @@
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
     auto* vec4_f32 = create<type::Vector>(f32, 4u);
     auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -335,11 +336,11 @@
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
     auto* vec4_f32 = create<type::Vector>(f32, 4u);
     auto* tex = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -355,11 +356,11 @@
     auto* i32 = create<type::I32>();
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
     auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -375,11 +376,11 @@
     auto* i32 = create<type::I32>();
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
     auto* tex = create<type::DepthMultisampledTexture>(type::TextureDimension::k2d);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -396,11 +397,11 @@
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
     auto* vec4_f32 = create<type::Vector>(f32, 4u);
     auto* tex = create<type::ExternalTexture>();
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
     EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 2u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -419,11 +420,12 @@
         create<type::StorageTexture>(type::TextureDimension::k2d, builtin::TexelFormat::kR32Float,
                                      builtin::Access::kWrite, subtype);
 
-    auto result = table->Lookup(BuiltinType::kTextureStore, utils::Vector{tex, vec2_i32, vec4_f32},
-                                sem::EvaluationStage::kConstant, Source{});
+    auto result =
+        table->Lookup(builtin::Function::kTextureStore, utils::Vector{tex, vec2_i32, vec4_f32},
+                      sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureStore);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureStore);
     EXPECT_TRUE(result.sem->ReturnType()->Is<type::Void>());
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -438,7 +440,7 @@
     auto* f32 = create<type::F32>();
     auto* i32 = create<type::I32>();
     auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{f32, vec2_i32},
+    auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{f32, vec2_i32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -446,7 +448,7 @@
 
 TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kCos,
+    auto result = table->Lookup(builtin::Function::kCos,
                                 utils::Vector{
                                     create<type::Reference>(f32, builtin::AddressSpace::kFunction,
                                                             builtin::Access::kReadWrite),
@@ -454,7 +456,7 @@
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kCos);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kCos);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -462,11 +464,11 @@
 
 TEST_F(IntrinsicTableTest, MatchTemplateType) {
     auto* f32 = create<type::F32>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, f32, f32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, f32, f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
     EXPECT_EQ(result.sem->Parameters()[1]->Type(), f32);
@@ -476,7 +478,7 @@
 TEST_F(IntrinsicTableTest, MismatchTemplateType) {
     auto* f32 = create<type::F32>();
     auto* u32 = create<type::U32>();
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, u32, f32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, u32, f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -485,11 +487,12 @@
 TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
     auto* f32 = create<type::F32>();
     auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, vec2_f32, vec2_f32},
-                                sem::EvaluationStage::kConstant, Source{});
+    auto result =
+        table->Lookup(builtin::Function::kClamp, utils::Vector{vec2_f32, vec2_f32, vec2_f32},
+                      sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
     EXPECT_EQ(result.sem->ReturnType(), vec2_f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), vec2_f32);
@@ -501,7 +504,7 @@
     auto* f32 = create<type::F32>();
     auto* u32 = create<type::U32>();
     auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, u32, vec2_f32},
+    auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{vec2_f32, u32, vec2_f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -511,11 +514,11 @@
     auto* f32 = create<type::F32>();
     auto* vec3_f32 = create<type::Vector>(f32, 3u);
     auto* mat3_f32 = create<type::Matrix>(vec3_f32, 3u);
-    auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3_f32},
+    auto result = table->Lookup(builtin::Function::kDeterminant, utils::Vector{mat3_f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kDeterminant);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kDeterminant);
     EXPECT_EQ(result.sem->ReturnType(), f32);
     ASSERT_EQ(result.sem->Parameters().Length(), 1u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), mat3_f32);
@@ -525,7 +528,7 @@
     auto* f32 = create<type::F32>();
     auto* vec2_f32 = create<type::Vector>(f32, 2u);
     auto* mat3x2_f32 = create<type::Matrix>(vec2_f32, 3u);
-    auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3x2_f32},
+    auto result = table->Lookup(builtin::Function::kDeterminant, utils::Vector{mat3x2_f32},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -534,12 +537,12 @@
 TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
     auto* af = create<type::AbstractFloat>();
     auto* bool_ = create<type::Bool>();
-    auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_},
+    auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{af, af, bool_},
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
     EXPECT_EQ(result.sem->Stage(), sem::EvaluationStage::kConstant);
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
     EXPECT_EQ(result.sem->ReturnType(), af);
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_EQ(result.sem->Parameters()[0]->Type(), af);
@@ -551,12 +554,12 @@
     auto* af = create<type::AbstractFloat>();
     auto* bool_ref = create<type::Reference>(create<type::Bool>(), builtin::AddressSpace::kFunction,
                                              builtin::Access::kReadWrite);
-    auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref},
+    auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{af, af, bool_ref},
                                 sem::EvaluationStage::kRuntime, Source{});
     ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
     EXPECT_EQ(result.sem->Stage(), sem::EvaluationStage::kConstant);
-    EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+    EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
     EXPECT_TRUE(result.sem->ReturnType()->Is<type::F32>());
     ASSERT_EQ(result.sem->Parameters().Length(), 3u);
     EXPECT_TRUE(result.sem->Parameters()[0]->Type()->Is<type::F32>());
@@ -594,7 +597,7 @@
     // None of the arguments match, so expect the overloads with 2 parameters to
     // come first
     auto* bool_ = create<type::Bool>();
-    table->Lookup(BuiltinType::kTextureDimensions, utils::Vector{bool_, bool_},
+    table->Lookup(builtin::Function::kTextureDimensions, utils::Vector{bool_, bool_},
                   sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(Diagnostics().str(),
               R"(error: no matching call to textureDimensions(bool, bool)
@@ -633,7 +636,7 @@
 TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
     auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
     auto* bool_ = create<type::Bool>();
-    table->Lookup(BuiltinType::kTextureDimensions, utils::Vector{tex, bool_},
+    table->Lookup(builtin::Function::kTextureDimensions, utils::Vector{tex, bool_},
                   sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(Diagnostics().str(),
               R"(error: no matching call to textureDimensions(texture_depth_2d, bool)
@@ -673,16 +676,16 @@
     auto* f32 = create<type::F32>();
     auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
     auto* bool_ = create<type::Bool>();
-    auto a = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+    auto a = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
                            sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(a.sem, nullptr) << Diagnostics().str();
 
-    auto b = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+    auto b = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
                            sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(b.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
 
-    auto c = table->Lookup(BuiltinType::kSelect, utils::Vector{vec2_f32, vec2_f32, bool_},
+    auto c = table->Lookup(builtin::Function::kSelect, utils::Vector{vec2_f32, vec2_f32, bool_},
                            sem::EvaluationStage::kConstant, Source{});
     ASSERT_NE(c.sem, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
@@ -1022,7 +1025,7 @@
     auto* f32 = create<type::F32>();
     utils::Vector<const type::Type*, 0> arg_tys;
     arg_tys.Resize(257, f32);
-    auto result = table->Lookup(BuiltinType::kAbs, std::move(arg_tys),
+    auto result = table->Lookup(builtin::Function::kAbs, std::move(arg_tys),
                                 sem::EvaluationStage::kConstant, Source{});
     ASSERT_EQ(result.sem, nullptr);
     ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -1261,7 +1264,7 @@
     auto* arg_a = GetParam().arg_a(*this);
     auto* arg_b = GetParam().arg_b(*this);
     auto* arg_c = GetParam().arg_c(*this);
-    auto builtin = table->Lookup(sem::BuiltinType::kClamp, utils::Vector{arg_a, arg_b, arg_c},
+    auto builtin = table->Lookup(builtin::Function::kClamp, utils::Vector{arg_a, arg_b, arg_c},
                                  sem::EvaluationStage::kConstant, Source{{12, 34}});
 
     bool matched = builtin.sem != nullptr;
diff --git a/src/tint/resolver/materialize_test.cc b/src/tint/resolver/materialize_test.cc
index 839389a..6fa2010 100644
--- a/src/tint/resolver/materialize_test.cc
+++ b/src/tint/resolver/materialize_test.cc
@@ -16,6 +16,7 @@
 
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/test_helper.h"
 
 #include "gmock/gmock.h"
@@ -939,7 +940,7 @@
             break;
         }
         case Method::kTintMaterializeBuiltin: {
-            auto* call = Call(sem::str(sem::BuiltinType::kTintMaterialize), abstract_expr());
+            auto* call = Call(builtin::str(builtin::Function::kTintMaterialize), abstract_expr());
             WrapInFunction(Decl(Const("c", call)));
             break;
         }
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index f51e5cc..2cd40e9 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -260,7 +260,7 @@
         ty = rhs->Type()->UnwrapRef();  // Implicit load of RHS
     }
 
-    if (rhs && !validator_.VariableInitializer(v, builtin::AddressSpace::kUndefined, ty, rhs)) {
+    if (rhs && !validator_.VariableInitializer(v, ty, rhs)) {
         return nullptr;
     }
 
@@ -323,7 +323,7 @@
         return nullptr;
     }
 
-    if (rhs && !validator_.VariableInitializer(v, builtin::AddressSpace::kUndefined, ty, rhs)) {
+    if (rhs && !validator_.VariableInitializer(v, ty, rhs)) {
         return nullptr;
     }
 
@@ -417,7 +417,7 @@
         ty = rhs->Type();
     }
 
-    if (!validator_.VariableInitializer(c, builtin::AddressSpace::kUndefined, ty, rhs)) {
+    if (!validator_.VariableInitializer(c, ty, rhs)) {
         return nullptr;
     }
 
@@ -516,7 +516,7 @@
         access = DefaultAccessForAddressSpace(address_space);
     }
 
-    if (rhs && !validator_.VariableInitializer(var, address_space, storage_ty, rhs)) {
+    if (rhs && !validator_.VariableInitializer(var, storage_ty, rhs)) {
         return nullptr;
     }
 
@@ -2156,7 +2156,12 @@
             return Switch(
                 sem_.Get(ast_node),  //
                 [&](type::Type* t) { return ty_init_or_conv(t); },
-                [&](sem::Function* f) { return FunctionCall(expr, f, args, arg_behaviors); },
+                [&](sem::Function* f) -> sem::Call* {
+                    if (!TINT_LIKELY(CheckNotTemplated("function", ident))) {
+                        return nullptr;
+                    }
+                    return FunctionCall(expr, f, args, arg_behaviors);
+                },
                 [&](sem::Expression* e) {
                     sem_.ErrorUnexpectedExprKind(e, "call target");
                     return nullptr;
@@ -2167,7 +2172,10 @@
                 });
         }
 
-        if (auto f = resolved->BuiltinFunction(); f != sem::BuiltinType::kNone) {
+        if (auto f = resolved->BuiltinFunction(); f != builtin::Function::kNone) {
+            if (!TINT_LIKELY(CheckNotTemplated("builtin", ident))) {
+                return nullptr;
+            }
             return BuiltinCall(expr, f, args);
         }
 
@@ -2239,7 +2247,7 @@
 
 template <size_t N>
 sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
-                                 sem::BuiltinType builtin_type,
+                                 builtin::Function builtin_type,
                                  utils::Vector<const sem::ValueExpression*, N>& args) {
     auto arg_stage = sem::EvaluationStage::kConstant;
     for (auto* arg : args) {
@@ -2255,7 +2263,7 @@
         }
     }
 
-    if (builtin_type == sem::BuiltinType::kTintMaterialize) {
+    if (builtin_type == builtin::Function::kTintMaterialize) {
         args[0] = Materialize(args[0]);
         if (!args[0]) {
             return nullptr;
@@ -2307,14 +2315,14 @@
         return nullptr;
     }
 
-    if (IsTextureBuiltin(builtin_type)) {
+    if (sem::IsTextureBuiltin(builtin_type)) {
         if (!validator_.TextureBuiltinFunction(call)) {
             return nullptr;
         }
         CollectTextureSamplerPairs(builtin.sem, call->Arguments());
     }
 
-    if (builtin_type == sem::BuiltinType::kWorkgroupUniformLoad) {
+    if (builtin_type == builtin::Function::kWorkgroupUniformLoad) {
         if (!validator_.WorkgroupUniformLoad(call)) {
             return nullptr;
         }
@@ -2331,13 +2339,7 @@
     auto& b = *builder_;
 
     auto check_no_tmpl_args = [&](type::Type* ty) -> type::Type* {
-        if (TINT_UNLIKELY(ident->Is<ast::TemplatedIdentifier>())) {
-            AddError("type '" + b.Symbols().NameFor(ident->symbol) +
-                         "' does not take template arguments",
-                     ident->source);
-            return nullptr;
-        }
-        return ty;
+        return TINT_LIKELY(CheckNotTemplated("type", ident)) ? ty : nullptr;
     };
     auto f32 = [&] { return b.create<type::F32>(); };
     auto i32 = [&] { return b.create<type::I32>(); };
@@ -3019,25 +3021,15 @@
                 return user;
             },
             [&](const type::Type* ty) -> sem::TypeExpression* {
-                if (TINT_UNLIKELY(ident->Is<ast::TemplatedIdentifier>())) {
-                    AddError("type '" + builder_->Symbols().NameFor(ident->symbol) +
-                                 "' does not take template arguments",
-                             ident->source);
-                    sem_.NoteDeclarationSource(ast_node);
+                if (!TINT_LIKELY(CheckNotTemplated("type", ident))) {
                     return nullptr;
                 }
-
                 return builder_->create<sem::TypeExpression>(expr, current_statement_, ty);
             },
             [&](const sem::Function* fn) -> sem::FunctionExpression* {
-                if (TINT_UNLIKELY(ident->Is<ast::TemplatedIdentifier>())) {
-                    AddError("function '" + builder_->Symbols().NameFor(ident->symbol) +
-                                 "' does not take template arguments",
-                             ident->source);
-                    sem_.NoteDeclarationSource(ast_node);
+                if (!TINT_LIKELY(CheckNotTemplated("function", ident))) {
                     return nullptr;
                 }
-
                 return builder_->create<sem::FunctionExpression>(expr, current_statement_, fn);
             });
     }
@@ -3050,7 +3042,7 @@
         return builder_->create<sem::TypeExpression>(expr, current_statement_, ty);
     }
 
-    if (resolved->BuiltinFunction() != sem::BuiltinType::kNone) {
+    if (resolved->BuiltinFunction() != builtin::Function::kNone) {
         AddError("missing '(' for builtin function call", expr->source.End());
         return nullptr;
     }
@@ -3484,7 +3476,10 @@
 }
 
 bool Resolver::Enable(const ast::Enable* enable) {
-    enabled_extensions_.Add(enable->extension);
+    for (auto* ext : enable->extensions) {
+        Mark(ext);
+        enabled_extensions_.Add(ext->name);
+    }
     return true;
 }
 
@@ -4282,6 +4277,16 @@
             [&](const ast::BlockStatement* block) {
                 return handle_attributes(block, sem, "block statements");
             },
+            [&](const ast::ForLoopStatement* f) {
+                return handle_attributes(f, sem, "for statements");
+            },
+            [&](const ast::IfStatement* i) { return handle_attributes(i, sem, "if statements"); },
+            [&](const ast::SwitchStatement* s) {
+                return handle_attributes(s, sem, "switch statements");
+            },
+            [&](const ast::WhileStatement* w) {
+                return handle_attributes(w, sem, "while statements");
+            },
             [&](Default) { return true; })) {
         return nullptr;
     }
@@ -4329,6 +4334,21 @@
     }
 }
 
+bool Resolver::CheckNotTemplated(const char* use, const ast::Identifier* ident) {
+    if (TINT_UNLIKELY(ident->Is<ast::TemplatedIdentifier>())) {
+        AddError(std::string(use) + " '" + builder_->Symbols().NameFor(ident->symbol) +
+                     "' does not take template arguments",
+                 ident->source);
+        if (auto resolved = dependencies_.resolved_identifiers.Get(ident)) {
+            if (auto* ast_node = resolved->Node()) {
+                sem_.NoteDeclarationSource(ast_node);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
 void Resolver::ErrorMismatchedResolvedIdentifier(const Source& source,
                                                  const ResolvedIdentifier& resolved,
                                                  std::string_view wanted) {
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 8acf602..266f3a2 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -204,7 +204,7 @@
     sem::Expression* Identifier(const ast::IdentifierExpression*);
     template <size_t N>
     sem::Call* BuiltinCall(const ast::CallExpression*,
-                           sem::BuiltinType,
+                           builtin::Function,
                            utils::Vector<const sem::ValueExpression*, N>& args);
     sem::ValueExpression* Literal(const ast::LiteralExpression*);
     sem::ValueExpression* MemberAccessor(const ast::MemberAccessorExpression*);
@@ -480,6 +480,11 @@
     template <typename NODE>
     void ApplyDiagnosticSeverities(NODE* node);
 
+    /// Checks @p ident is not an ast::TemplatedIdentifier.
+    /// If @p ident is a ast::TemplatedIdentifier, then an error diagnostic is raised.
+    /// @returns true if @p ident is not a ast::TemplatedIdentifier.
+    bool CheckNotTemplated(const char* use, const ast::Identifier* ident);
+
     /// Raises an error diagnostic that the resolved identifier @p resolved was not of the expected
     /// kind.
     /// @param source the source of the error diagnostic
diff --git a/src/tint/resolver/sem_helper.cc b/src/tint/resolver/sem_helper.cc
index 45bdf41..36cc4c7 100644
--- a/src/tint/resolver/sem_helper.cc
+++ b/src/tint/resolver/sem_helper.cc
@@ -19,6 +19,7 @@
 #include "src/tint/sem/function_expression.h"
 #include "src/tint/sem/type_expression.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 
 namespace tint::resolver {
 
diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc
index bc4ac1d..7a4d25e 100644
--- a/src/tint/resolver/uniformity.cc
+++ b/src/tint/resolver/uniformity.cc
@@ -37,7 +37,9 @@
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/variable.h"
 #include "src/tint/sem/while_statement.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/block_allocator.h"
+#include "src/tint/utils/defer.h"
 #include "src/tint/utils/map.h"
 #include "src/tint/utils/string_stream.h"
 #include "src/tint/utils/unique_vector.h"
@@ -45,6 +47,10 @@
 // Set to `1` to dump the uniformity graph for each function in graphviz format.
 #define TINT_DUMP_UNIFORMITY_GRAPH 0
 
+#if TINT_DUMP_UNIFORMITY_GRAPH
+#include <iostream>
+#endif
+
 namespace tint::resolver {
 
 namespace {
@@ -123,7 +129,7 @@
     const ast::Node* ast = nullptr;
 
     /// The function call argument index, if applicable.
-    uint32_t arg_index;
+    uint32_t arg_index = 0xffffffffu;
 
     /// The set of edges from this node to other nodes in the graph.
     utils::UniqueVector<Node*, 4> edges;
@@ -547,14 +553,18 @@
             stmt,
 
             [&](const ast::AssignmentStatement* a) {
-                auto [cf1, v1] = ProcessExpression(cf, a->rhs);
                 if (a->lhs->Is<ast::PhonyExpression>()) {
-                    return cf1;
-                } else {
-                    auto [cf2, l2] = ProcessLValueExpression(cf1, a->lhs);
-                    l2->AddEdge(v1);
-                    return cf2;
+                    auto [cf_r, _] = ProcessExpression(cf, a->rhs);
+                    return cf_r;
                 }
+                auto [cf_l, v_l, ident] = ProcessLValueExpression(cf, a->lhs);
+                auto [cf_r, v_r] = ProcessExpression(cf_l, a->rhs);
+                v_l->AddEdge(v_r);
+
+                // Update the variable node for the LHS variable.
+                current_function_->variables.Set(ident, v_l);
+
+                return cf_r;
             },
 
             [&](const ast::BlockStatement* b) {
@@ -696,18 +706,31 @@
             },
 
             [&](const ast::CompoundAssignmentStatement* c) {
-                // The compound assignment statement `a += b` is equivalent to `a = a + b`.
-                // Note: we set load_rule=true when evaluating the LHS the first time, as the
-                // resolver does not add a load node for it.
-                auto [cf1, v1] = ProcessExpression(cf, c->lhs, /* load_rule */ true);
-                auto [cf2, v2] = ProcessExpression(cf1, c->rhs);
-                auto* result = CreateNode({"binary_expr_result"});
-                result->AddEdge(v1);
-                result->AddEdge(v2);
+                // The compound assignment statement `a += b` is equivalent to:
+                //   let p = &a;
+                //   *p = *p + b;
 
-                auto [cf3, l3] = ProcessLValueExpression(cf2, c->lhs);
-                l3->AddEdge(result);
-                return cf3;
+                // Evaluate the LHS.
+                auto [cf1, l1, ident] = ProcessLValueExpression(cf, c->lhs);
+
+                // Get the current value loaded from the LHS reference before evaluating the RHS.
+                auto* lhs_load = current_function_->variables.Get(ident);
+
+                // Evaluate the RHS.
+                auto [cf2, v2] = ProcessExpression(cf1, c->rhs);
+
+                // Create a node for the resulting value.
+                auto* result = CreateNode({"binary_expr_result"});
+                result->AddEdge(v2);
+                if (lhs_load) {
+                    result->AddEdge(lhs_load);
+                }
+
+                // Update the variable node for the LHS variable.
+                l1->AddEdge(result);
+                current_function_->variables.Set(ident, l1);
+
+                return cf2;
             },
 
             [&](const ast::ContinueStatement* c) {
@@ -958,16 +981,25 @@
 
             [&](const ast::IncrementDecrementStatement* i) {
                 // The increment/decrement statement `i++` is equivalent to `i = i + 1`.
-                // Note: we set load_rule=true when evaluating the LHS the first time, as the
-                // resolver does not add a load node for it.
-                auto [cf1, v1] = ProcessExpression(cf, i->lhs, /* load_rule */ true);
-                auto* result = CreateNode({"incdec_result"});
-                result->AddEdge(v1);
-                result->AddEdge(cf1);
 
-                auto [cf2, l2] = ProcessLValueExpression(cf1, i->lhs);
-                l2->AddEdge(result);
-                return cf2;
+                // Evaluate the LHS.
+                auto [cf1, l1, ident] = ProcessLValueExpression(cf, i->lhs);
+
+                // Get the current value loaded from the LHS reference.
+                auto* lhs_load = current_function_->variables.Get(ident);
+
+                // Create a node for the resulting value.
+                auto* result = CreateNode({"incdec_result"});
+                result->AddEdge(cf1);
+                if (lhs_load) {
+                    result->AddEdge(lhs_load);
+                }
+
+                // Update the variable node for the LHS variable.
+                l1->AddEdge(result);
+                current_function_->variables.Set(ident, l1);
+
+                return cf1;
             },
 
             [&](const ast::LoopStatement* l) {
@@ -1365,48 +1397,60 @@
         return false;
     }
 
+    /// LValue holds the Nodes returned by ProcessLValueExpression()
+    struct LValue {
+        /// The control-flow node for an LValue expression
+        Node* cf = nullptr;
+
+        /// The new value node for an LValue expression
+        Node* new_val = nullptr;
+
+        /// The root identifier for an LValue expression.
+        const sem::Variable* root_identifier = nullptr;
+    };
+
     /// Process an LValue expression.
     /// @param cf the input control flow node
     /// @param expr the expression to process
     /// @returns a pair of (control flow node, variable node)
-    std::pair<Node*, Node*> ProcessLValueExpression(Node* cf,
-                                                    const ast::Expression* expr,
-                                                    bool is_partial_reference = false) {
+    LValue ProcessLValueExpression(Node* cf,
+                                   const ast::Expression* expr,
+                                   bool is_partial_reference = false) {
         return Switch(
             expr,
 
             [&](const ast::IdentifierExpression* i) {
                 auto* sem = sem_.GetVal(i)->UnwrapLoad()->As<sem::VariableUser>();
                 if (sem->Variable()->Is<sem::GlobalVariable>()) {
-                    return std::make_pair(cf, current_function_->may_be_non_uniform);
+                    return LValue{cf, current_function_->may_be_non_uniform, nullptr};
                 } else if (auto* local = sem->Variable()->As<sem::LocalVariable>()) {
                     // Create a new value node for this variable.
                     auto* value = CreateNode({NameFor(i), "_lvalue"});
-                    auto* old_value = current_function_->variables.Set(local, value);
 
                     // If i is part of an expression that is a partial reference to a variable (e.g.
                     // index or member access), we link back to the variable's previous value. If
                     // the previous value was non-uniform, a partial assignment will not make it
                     // uniform.
+                    auto* old_value = current_function_->variables.Get(local);
                     if (is_partial_reference && old_value) {
                         value->AddEdge(old_value);
                     }
 
-                    return std::make_pair(cf, value);
+                    return LValue{cf, value, local};
                 } else {
                     TINT_ICE(Resolver, diagnostics_)
                         << "unknown lvalue identifier expression type: "
                         << std::string(sem->Variable()->TypeInfo().name);
-                    return std::pair<Node*, Node*>(nullptr, nullptr);
+                    return LValue{};
                 }
             },
 
             [&](const ast::IndexAccessorExpression* i) {
-                auto [cf1, l1] =
+                auto [cf1, l1, root_ident] =
                     ProcessLValueExpression(cf, i->object, /*is_partial_reference*/ true);
                 auto [cf2, v2] = ProcessExpression(cf1, i->index);
                 l1->AddEdge(v2);
-                return std::pair<Node*, Node*>(cf2, l1);
+                return LValue{cf2, l1, root_ident};
             },
 
             [&](const ast::MemberAccessorExpression* m) {
@@ -1419,17 +1463,16 @@
                     // that is being written to.
                     auto* root_ident = sem_.Get(u)->RootIdentifier();
                     auto* deref = CreateNode({NameFor(root_ident), "_deref"});
-                    auto* old_value = current_function_->variables.Set(root_ident, deref);
 
-                    if (old_value) {
-                        // If derefercing a partial reference or partial pointer, we link back to
+                    if (auto* old_value = current_function_->variables.Get(root_ident)) {
+                        // If dereferencing a partial reference or partial pointer, we link back to
                         // the variable's previous value. If the previous value was non-uniform, a
                         // partial assignment will not make it uniform.
                         if (is_partial_reference || IsDerefOfPartialPointer(u)) {
                             deref->AddEdge(old_value);
                         }
                     }
-                    return std::pair<Node*, Node*>(cf, deref);
+                    return LValue{cf, deref, root_ident};
                 }
                 return ProcessLValueExpression(cf, u->expr, is_partial_reference);
             },
@@ -1437,7 +1480,7 @@
             [&](Default) {
                 TINT_ICE(Resolver, diagnostics_)
                     << "unknown lvalue expression type: " << std::string(expr->TypeInfo().name);
-                return std::pair<Node*, Node*>(nullptr, nullptr);
+                return LValue{};
             });
     }
 
@@ -1514,12 +1557,12 @@
                 // some texture sampling builtins, and atomics.
                 if (builtin->IsBarrier()) {
                     callsite_tag = {CallSiteTag::CallSiteRequiredToBeUniform, default_severity};
-                } else if (builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+                } else if (builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
                     callsite_tag = {CallSiteTag::CallSiteRequiredToBeUniform, default_severity};
                 } else if (builtin->IsDerivative() ||
-                           builtin->Type() == sem::BuiltinType::kTextureSample ||
-                           builtin->Type() == sem::BuiltinType::kTextureSampleBias ||
-                           builtin->Type() == sem::BuiltinType::kTextureSampleCompare) {
+                           builtin->Type() == builtin::Function::kTextureSample ||
+                           builtin->Type() == builtin::Function::kTextureSampleBias ||
+                           builtin->Type() == builtin::Function::kTextureSampleCompare) {
                     // Get the severity of derivative uniformity violations in this context.
                     auto severity = sem_.DiagnosticSeverity(
                         call, builtin::DiagnosticRule::kDerivativeUniformity);
@@ -1626,7 +1669,7 @@
                 }
             } else {
                 auto* builtin = sem->Target()->As<sem::Builtin>();
-                if (builtin && builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+                if (builtin && builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
                     // The workgroupUniformLoad builtin requires its parameter to be uniform.
                     current_function_->RequiredToBeUniform(default_severity)->AddEdge(args[i]);
                 } else {
diff --git a/src/tint/resolver/uniformity_test.cc b/src/tint/resolver/uniformity_test.cc
index 51608bd..e166a06 100644
--- a/src/tint/resolver/uniformity_test.cc
+++ b/src/tint/resolver/uniformity_test.cc
@@ -7402,6 +7402,377 @@
 )");
 }
 
+TEST_F(UniformityAnalysisTest, CompoundAssignment_Global) {
+    // Use compound assignment on a global variable.
+    // Tests that we do not assume there is always a variable node for the LHS, but we still process
+    // the expression.
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> rw : i32;
+
+var<private> v : array<i32, 4>;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var f = rw;
+  v[bar(&f)] += 1;
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:8:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:7:3 note: control flow depends on possibly non-uniform value
+  if (*p == 0) {
+  ^^
+
+test:7:8 note: parameter 'p' of 'bar' may be non-uniform
+  if (*p == 0) {
+       ^
+
+test:15:9 note: possibly non-uniform value passed via pointer here
+  v[bar(&f)] += 1;
+        ^
+
+test:14:11 note: reading from read_write storage buffer 'rw' may result in a non-uniform value
+  var f = rw;
+          ^^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, IncDec_StillNonUniform) {
+    // Use increment on a variable that is already non-uniform.
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> rw : i32;
+
+fn foo() {
+  var v = rw;
+  v++;
+  if (v == 0) {
+    workgroupBarrier();
+  }
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:8:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:7:3 note: control flow depends on possibly non-uniform value
+  if (v == 0) {
+  ^^
+
+test:5:11 note: reading from read_write storage buffer 'rw' may result in a non-uniform value
+  var v = rw;
+          ^^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, IncDec_Global) {
+    // Use increment on a global variable.
+    // Tests that we do not assume there is always a variable node for the LHS, but we still process
+    // the expression.
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> rw : i32;
+
+var<private> v : array<i32, 4>;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var f = rw;
+  v[bar(&f)]++;
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:8:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:7:3 note: control flow depends on possibly non-uniform value
+  if (*p == 0) {
+  ^^
+
+test:7:8 note: parameter 'p' of 'bar' may be non-uniform
+  if (*p == 0) {
+       ^
+
+test:15:9 note: possibly non-uniform value passed via pointer here
+  v[bar(&f)]++;
+        ^
+
+test:14:11 note: reading from read_write storage buffer 'rw' may result in a non-uniform value
+  var f = rw;
+          ^^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, AssignmentEval_LHS_Then_RHS_Pass) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn b(p : ptr<function, i32>) -> i32 {
+  *p = non_uniform;
+  return 0;
+}
+
+fn a(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var i = 0;
+  var arr : array<i32, 4>;
+  arr[a(&i)] = arr[b(&i)];
+}
+)";
+
+    RunTest(src, true);
+}
+
+TEST_F(UniformityAnalysisTest, AssignmentEval_LHS_Then_RHS_Fail) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn a(p : ptr<function, i32>) -> i32 {
+  *p = non_uniform;
+  return 0;
+}
+
+fn b(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var i = 0;
+  var arr : array<i32, 4>;
+  arr[a(&i)] = arr[b(&i)];
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:11:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:10:3 note: control flow depends on possibly non-uniform value
+  if (*p == 0) {
+  ^^
+
+test:10:8 note: parameter 'p' of 'b' may be non-uniform
+  if (*p == 0) {
+       ^
+
+test:19:22 note: possibly non-uniform value passed via pointer here
+  arr[a(&i)] = arr[b(&i)];
+                     ^
+
+test:19:9 note: contents of pointer may become non-uniform after calling 'a'
+  arr[a(&i)] = arr[b(&i)];
+        ^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, CompoundAssignmentEval_LHS_Then_RHS_Pass) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn b(p : ptr<function, i32>) -> i32 {
+  *p = non_uniform;
+  return 0;
+}
+
+fn a(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var i = 0;
+  var arr : array<i32, 4>;
+  arr[a(&i)] += arr[b(&i)];
+}
+)";
+
+    RunTest(src, true);
+}
+
+TEST_F(UniformityAnalysisTest, CompoundAssignmentEval_LHS_Then_RHS_Fail) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn a(p : ptr<function, i32>) -> i32 {
+  *p = non_uniform;
+  return 0;
+}
+
+fn b(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  return 0;
+}
+
+fn foo() {
+  var i = 0;
+  var arr : array<i32, 4>;
+  arr[a(&i)] += arr[b(&i)];
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:11:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:10:3 note: control flow depends on possibly non-uniform value
+  if (*p == 0) {
+  ^^
+
+test:10:8 note: parameter 'p' of 'b' may be non-uniform
+  if (*p == 0) {
+       ^
+
+test:19:23 note: possibly non-uniform value passed via pointer here
+  arr[a(&i)] += arr[b(&i)];
+                      ^
+
+test:19:9 note: contents of pointer may become non-uniform after calling 'a'
+  arr[a(&i)] += arr[b(&i)];
+        ^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, CompoundAssignmentEval_RHS_Makes_LHS_NonUniform_After_Load) {
+    // Test that the LHS is loaded from before the RHS makes is evaluated.
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  *p = non_uniform;
+  return 0;
+}
+
+fn foo() {
+  var i = 0;
+  var arr : array<i32, 4>;
+  i += arr[bar(&i)];
+  if (i == 0) {
+    workgroupBarrier();
+  }
+}
+)";
+
+    RunTest(src, true);
+}
+
+TEST_F(UniformityAnalysisTest, CompoundAssignmentEval_RHS_Makes_LHS_Uniform_After_Load) {
+    // Test that the LHS is loaded from before the RHS makes is evaluated.
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  *p = 0;
+  return 0;
+}
+
+fn foo() {
+  var i = non_uniform;
+  var arr : array<i32, 4>;
+  i += arr[bar(&i)];
+  if (i == 0) {
+    workgroupBarrier();
+  }
+}
+)";
+
+    RunTest(src, false);
+    EXPECT_EQ(error_,
+              R"(test:14:5 error: 'workgroupBarrier' must only be called from uniform control flow
+    workgroupBarrier();
+    ^^^^^^^^^^^^^^^^
+
+test:13:3 note: control flow depends on possibly non-uniform value
+  if (i == 0) {
+  ^^
+
+test:10:11 note: reading from read_write storage buffer 'non_uniform' may result in a non-uniform value
+  var i = non_uniform;
+          ^^^^^^^^^^^
+)");
+}
+
+TEST_F(UniformityAnalysisTest, CompoundAssignmentEval_LHS_OnlyOnce) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  *p = non_uniform;
+  return 0;
+}
+
+fn foo(){
+  var f : i32 = 0;
+  var arr : array<i32, 4>;
+  arr[bar(&f)] += 1;
+}
+)";
+
+    RunTest(src, true);
+}
+
+TEST_F(UniformityAnalysisTest, IncDec_LHS_OnlyOnce) {
+    std::string src = R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+
+fn bar(p : ptr<function, i32>) -> i32 {
+  if (*p == 0) {
+    workgroupBarrier();
+  }
+  *p = non_uniform;
+  return 0;
+}
+
+fn foo(){
+  var f : i32 = 0;
+  var arr : array<i32, 4>;
+  arr[bar(&f)]++;
+}
+)";
+
+    RunTest(src, true);
+}
+
 TEST_F(UniformityAnalysisTest, ShortCircuiting_UniformLHS) {
     std::string src = R"(
 @group(0) @binding(0) var<storage, read> uniform_global : i32;
@@ -8005,6 +8376,278 @@
     }
 }
 
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnForStatement_CallInInitializer) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(for (var b = (non_uniform == 42 && dpdx(1.0) > 0.0); false;) {
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnForStatement_CallInCondition) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(for (; non_uniform == 42 && dpdx(1.0) > 0.0;) {
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnForStatement_CallInIncrement) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(for (var b = false; false; b = (non_uniform == 42 && dpdx(1.0) > 0.0)) {
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnForStatement_CallInBody) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+@group(0) @binding(1) var t : texture_2d<f32>;
+@group(0) @binding(2) var s : sampler;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(for (; non_uniform == 42;) {
+    let color = textureSample(t, s, vec2(0, 0));
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'textureSample' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnIfStatement_CallInCondition) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(if (non_uniform == 42 && dpdx(1.0) > 0.0) {
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnIfStatement_CallInBody) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+@group(0) @binding(1) var t : texture_2d<f32>;
+@group(0) @binding(2) var s : sampler;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(if (non_uniform == 42) {
+    let color = textureSample(t, s, vec2(0, 0));
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'textureSample' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnIfStatement_CallInElse) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+@group(0) @binding(1) var t : texture_2d<f32>;
+@group(0) @binding(2) var s : sampler;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(if (non_uniform == 42) {
+  } else {
+    let color = textureSample(t, s, vec2(0, 0));
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'textureSample' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnSwitchStatement_CallInCondition) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(switch (i32(non_uniform == 42 && dpdx(1.0) > 0.0)) {
+    default {}
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnSwitchStatement_CallInBody) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+@group(0) @binding(1) var t : texture_2d<f32>;
+@group(0) @binding(2) var s : sampler;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(switch (non_uniform) {
+    default {
+      let color = textureSample(t, s, vec2(0, 0));
+    }
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'textureSample' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnWhileStatement_CallInCondition) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(while (non_uniform == 42 && dpdx(1.0) > 0.0) {
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'dpdx' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
+TEST_P(UniformityAnalysisDiagnosticFilterTest, AttributeOnWhileStatement_CallInBody) {
+    auto& param = GetParam();
+    utils::StringStream ss;
+    ss << R"(
+@group(0) @binding(0) var<storage, read_write> non_uniform : i32;
+@group(0) @binding(1) var t : texture_2d<f32>;
+@group(0) @binding(2) var s : sampler;
+fn foo() {
+  )"
+       << "@diagnostic(" << param << ", derivative_uniformity)"
+       << R"(while (non_uniform == 42) {
+    let color = textureSample(t, s, vec2(0, 0));
+  }
+}
+)";
+
+    RunTest(ss.str(), param != builtin::DiagnosticSeverity::kError);
+    if (param == builtin::DiagnosticSeverity::kOff) {
+        EXPECT_TRUE(error_.empty());
+    } else {
+        utils::StringStream err;
+        err << ToStr(param) << ": 'textureSample' must only be called";
+        EXPECT_THAT(error_, ::testing::HasSubstr(err.str()));
+    }
+}
+
 INSTANTIATE_TEST_SUITE_P(UniformityAnalysisTest,
                          UniformityAnalysisDiagnosticFilterTest,
                          ::testing::Values(builtin::DiagnosticSeverity::kError,
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index f8f4c4d..c3b8a3d 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -373,7 +373,6 @@
 }
 
 bool Validator::VariableInitializer(const ast::Variable* v,
-                                    builtin::AddressSpace address_space,
                                     const type::Type* storage_ty,
                                     const sem::ValueExpression* initializer) const {
     auto* initializer_ty = initializer->Type();
@@ -388,23 +387,6 @@
         return false;
     }
 
-    if (v->Is<ast::Var>()) {
-        switch (address_space) {
-            case builtin::AddressSpace::kPrivate:
-            case builtin::AddressSpace::kFunction:
-                break;  // Allowed an initializer
-            default:
-                // https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
-                // Optionally has an initializer expression, if the variable is in the private or
-                // function address spaces.
-                AddError("var of address space '" + utils::ToString(address_space) +
-                             "' cannot have an initializer. var initializers are only supported "
-                             "for the address spaces 'private' and 'function'",
-                         v->source);
-                return false;
-        }
-    }
-
     return true;
 }
 
@@ -728,6 +710,23 @@
         }
     }
 
+    if (var->initializer) {
+        switch (v->AddressSpace()) {
+            case builtin::AddressSpace::kPrivate:
+            case builtin::AddressSpace::kFunction:
+                break;  // Allowed an initializer
+            default:
+                // https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
+                // Optionally has an initializer expression, if the variable is in the private or
+                // function address spaces.
+                AddError("var of address space '" + utils::ToString(v->AddressSpace()) +
+                             "' cannot have an initializer. var initializers are only supported "
+                             "for the address spaces 'private' and 'function'",
+                         var->source);
+                return false;
+        }
+    }
+
     if (!CheckTypeAccessAddressSpace(v->Type()->UnwrapRef(), v->Access(), v->AddressSpace(),
                                      var->attributes, var->source)) {
         return false;
diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h
index 45c98c8..e0e3051 100644
--- a/src/tint/resolver/validator.h
+++ b/src/tint/resolver/validator.h
@@ -429,12 +429,10 @@
 
     /// Validates a variable initializer
     /// @param v the variable to validate
-    /// @param address_space the address space of the variable
     /// @param storage_type the type of the storage
     /// @param initializer the RHS initializer expression
     /// @returns true on succes, false otherwise
     bool VariableInitializer(const ast::Variable* v,
-                             builtin::AddressSpace address_space,
                              const type::Type* storage_type,
                              const sem::ValueExpression* initializer) const;
 
diff --git a/src/tint/resolver/variable_validation_test.cc b/src/tint/resolver/variable_validation_test.cc
index 6ca3a08..7f62e8e 100644
--- a/src/tint/resolver/variable_validation_test.cc
+++ b/src/tint/resolver/variable_validation_test.cc
@@ -58,6 +58,26 @@
     EXPECT_EQ(r()->error(), "12:34 error: builtin 'storageBarrier' does not return a value");
 }
 
+TEST_F(ResolverVariableValidationTest, GlobalVarNoAddressSpace) {
+    // var a : i32;
+    GlobalVar(Source{{12, 34}}, "a", ty.i32());
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(
+        r()->error(),
+        R"(12:34 error: module-scope 'var' declarations that are not of texture or sampler types must provide an address space)");
+}
+
+TEST_F(ResolverVariableValidationTest, GlobalVarWithInitializerNoAddressSpace) {
+    // var a = 1;
+    GlobalVar(Source{{12, 34}}, "a", Expr(1_a));
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(
+        r()->error(),
+        R"(12:34 error: module-scope 'var' declarations that are not of texture or sampler types must provide an address space)");
+}
+
 TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) {
     // var<private> a : i32;
     // var<private> b : i32 = a;
diff --git a/src/tint/sem/builtin.cc b/src/tint/sem/builtin.cc
index 4fd2c34..4f33ebb 100644
--- a/src/tint/sem/builtin.cc
+++ b/src/tint/sem/builtin.cc
@@ -27,74 +27,76 @@
 namespace tint::sem {
 
 const char* Builtin::str() const {
-    return sem::str(type_);
+    return builtin::str(type_);
 }
 
-bool IsCoarseDerivativeBuiltin(BuiltinType i) {
-    return i == BuiltinType::kDpdxCoarse || i == BuiltinType::kDpdyCoarse ||
-           i == BuiltinType::kFwidthCoarse;
+bool IsCoarseDerivativeBuiltin(builtin::Function i) {
+    return i == builtin::Function::kDpdxCoarse || i == builtin::Function::kDpdyCoarse ||
+           i == builtin::Function::kFwidthCoarse;
 }
 
-bool IsFineDerivativeBuiltin(BuiltinType i) {
-    return i == BuiltinType::kDpdxFine || i == BuiltinType::kDpdyFine ||
-           i == BuiltinType::kFwidthFine;
+bool IsFineDerivativeBuiltin(builtin::Function i) {
+    return i == builtin::Function::kDpdxFine || i == builtin::Function::kDpdyFine ||
+           i == builtin::Function::kFwidthFine;
 }
 
-bool IsDerivativeBuiltin(BuiltinType i) {
-    return i == BuiltinType::kDpdx || i == BuiltinType::kDpdy || i == BuiltinType::kFwidth ||
-           IsCoarseDerivativeBuiltin(i) || IsFineDerivativeBuiltin(i);
+bool IsDerivativeBuiltin(builtin::Function i) {
+    return i == builtin::Function::kDpdx || i == builtin::Function::kDpdy ||
+           i == builtin::Function::kFwidth || IsCoarseDerivativeBuiltin(i) ||
+           IsFineDerivativeBuiltin(i);
 }
 
-bool IsTextureBuiltin(BuiltinType i) {
-    return IsImageQueryBuiltin(i) ||                           //
-           i == BuiltinType::kTextureGather ||                 //
-           i == BuiltinType::kTextureGatherCompare ||          //
-           i == BuiltinType::kTextureLoad ||                   //
-           i == BuiltinType::kTextureSample ||                 //
-           i == BuiltinType::kTextureSampleBaseClampToEdge ||  //
-           i == BuiltinType::kTextureSampleBias ||             //
-           i == BuiltinType::kTextureSampleCompare ||          //
-           i == BuiltinType::kTextureSampleCompareLevel ||     //
-           i == BuiltinType::kTextureSampleGrad ||             //
-           i == BuiltinType::kTextureSampleLevel ||            //
-           i == BuiltinType::kTextureStore;
+bool IsTextureBuiltin(builtin::Function i) {
+    return IsImageQueryBuiltin(i) ||                                 //
+           i == builtin::Function::kTextureGather ||                 //
+           i == builtin::Function::kTextureGatherCompare ||          //
+           i == builtin::Function::kTextureLoad ||                   //
+           i == builtin::Function::kTextureSample ||                 //
+           i == builtin::Function::kTextureSampleBaseClampToEdge ||  //
+           i == builtin::Function::kTextureSampleBias ||             //
+           i == builtin::Function::kTextureSampleCompare ||          //
+           i == builtin::Function::kTextureSampleCompareLevel ||     //
+           i == builtin::Function::kTextureSampleGrad ||             //
+           i == builtin::Function::kTextureSampleLevel ||            //
+           i == builtin::Function::kTextureStore;
 }
 
-bool IsImageQueryBuiltin(BuiltinType i) {
-    return i == BuiltinType::kTextureDimensions || i == BuiltinType::kTextureNumLayers ||
-           i == BuiltinType::kTextureNumLevels || i == BuiltinType::kTextureNumSamples;
+bool IsImageQueryBuiltin(builtin::Function i) {
+    return i == builtin::Function::kTextureDimensions ||
+           i == builtin::Function::kTextureNumLayers || i == builtin::Function::kTextureNumLevels ||
+           i == builtin::Function::kTextureNumSamples;
 }
 
-bool IsDataPackingBuiltin(BuiltinType i) {
-    return i == BuiltinType::kPack4X8Snorm || i == BuiltinType::kPack4X8Unorm ||
-           i == BuiltinType::kPack2X16Snorm || i == BuiltinType::kPack2X16Unorm ||
-           i == BuiltinType::kPack2X16Float;
+bool IsDataPackingBuiltin(builtin::Function i) {
+    return i == builtin::Function::kPack4X8Snorm || i == builtin::Function::kPack4X8Unorm ||
+           i == builtin::Function::kPack2X16Snorm || i == builtin::Function::kPack2X16Unorm ||
+           i == builtin::Function::kPack2X16Float;
 }
 
-bool IsDataUnpackingBuiltin(BuiltinType i) {
-    return i == BuiltinType::kUnpack4X8Snorm || i == BuiltinType::kUnpack4X8Unorm ||
-           i == BuiltinType::kUnpack2X16Snorm || i == BuiltinType::kUnpack2X16Unorm ||
-           i == BuiltinType::kUnpack2X16Float;
+bool IsDataUnpackingBuiltin(builtin::Function i) {
+    return i == builtin::Function::kUnpack4X8Snorm || i == builtin::Function::kUnpack4X8Unorm ||
+           i == builtin::Function::kUnpack2X16Snorm || i == builtin::Function::kUnpack2X16Unorm ||
+           i == builtin::Function::kUnpack2X16Float;
 }
 
-bool IsBarrierBuiltin(BuiltinType i) {
-    return i == BuiltinType::kWorkgroupBarrier || i == BuiltinType::kStorageBarrier;
+bool IsBarrierBuiltin(builtin::Function i) {
+    return i == builtin::Function::kWorkgroupBarrier || i == builtin::Function::kStorageBarrier;
 }
 
-bool IsAtomicBuiltin(BuiltinType i) {
-    return i == sem::BuiltinType::kAtomicLoad || i == sem::BuiltinType::kAtomicStore ||
-           i == sem::BuiltinType::kAtomicAdd || i == sem::BuiltinType::kAtomicSub ||
-           i == sem::BuiltinType::kAtomicMax || i == sem::BuiltinType::kAtomicMin ||
-           i == sem::BuiltinType::kAtomicAnd || i == sem::BuiltinType::kAtomicOr ||
-           i == sem::BuiltinType::kAtomicXor || i == sem::BuiltinType::kAtomicExchange ||
-           i == sem::BuiltinType::kAtomicCompareExchangeWeak;
+bool IsAtomicBuiltin(builtin::Function i) {
+    return i == builtin::Function::kAtomicLoad || i == builtin::Function::kAtomicStore ||
+           i == builtin::Function::kAtomicAdd || i == builtin::Function::kAtomicSub ||
+           i == builtin::Function::kAtomicMax || i == builtin::Function::kAtomicMin ||
+           i == builtin::Function::kAtomicAnd || i == builtin::Function::kAtomicOr ||
+           i == builtin::Function::kAtomicXor || i == builtin::Function::kAtomicExchange ||
+           i == builtin::Function::kAtomicCompareExchangeWeak;
 }
 
-bool IsDP4aBuiltin(BuiltinType i) {
-    return i == sem::BuiltinType::kDot4I8Packed || i == sem::BuiltinType::kDot4U8Packed;
+bool IsDP4aBuiltin(builtin::Function i) {
+    return i == builtin::Function::kDot4I8Packed || i == builtin::Function::kDot4U8Packed;
 }
 
-Builtin::Builtin(BuiltinType type,
+Builtin::Builtin(builtin::Function type,
                  const type::Type* return_type,
                  utils::VectorRef<Parameter*> parameters,
                  EvaluationStage eval_stage,
@@ -150,18 +152,18 @@
 
 bool Builtin::HasSideEffects() const {
     switch (type_) {
-        case sem::BuiltinType::kAtomicAdd:
-        case sem::BuiltinType::kAtomicAnd:
-        case sem::BuiltinType::kAtomicCompareExchangeWeak:
-        case sem::BuiltinType::kAtomicExchange:
-        case sem::BuiltinType::kAtomicMax:
-        case sem::BuiltinType::kAtomicMin:
-        case sem::BuiltinType::kAtomicOr:
-        case sem::BuiltinType::kAtomicStore:
-        case sem::BuiltinType::kAtomicSub:
-        case sem::BuiltinType::kAtomicXor:
-        case sem::BuiltinType::kTextureStore:
-        case sem::BuiltinType::kWorkgroupUniformLoad:
+        case builtin::Function::kAtomicAdd:
+        case builtin::Function::kAtomicAnd:
+        case builtin::Function::kAtomicCompareExchangeWeak:
+        case builtin::Function::kAtomicExchange:
+        case builtin::Function::kAtomicMax:
+        case builtin::Function::kAtomicMin:
+        case builtin::Function::kAtomicOr:
+        case builtin::Function::kAtomicStore:
+        case builtin::Function::kAtomicSub:
+        case builtin::Function::kAtomicXor:
+        case builtin::Function::kTextureStore:
+        case builtin::Function::kWorkgroupUniformLoad:
             return true;
         default:
             break;
diff --git a/src/tint/sem/builtin.h b/src/tint/sem/builtin.h
index 55d882e..b535e72 100644
--- a/src/tint/sem/builtin.h
+++ b/src/tint/sem/builtin.h
@@ -19,7 +19,7 @@
 #include <vector>
 
 #include "src/tint/builtin/extension.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
 #include "src/tint/sem/call_target.h"
 #include "src/tint/sem/pipeline_stage_set.h"
 #include "src/tint/utils/hash.h"
@@ -29,52 +29,52 @@
 /// Determines if the given `i` is a coarse derivative
 /// @param i the builtin type
 /// @returns true if the given derivative is coarse.
-bool IsCoarseDerivativeBuiltin(BuiltinType i);
+bool IsCoarseDerivativeBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a fine derivative
 /// @param i the builtin type
 /// @returns true if the given derivative is fine.
-bool IsFineDerivativeBuiltin(BuiltinType i);
+bool IsFineDerivativeBuiltin(builtin::Function i);
 
 /// Determine if the given `i` is a derivative builtin
 /// @param i the builtin type
 /// @returns true if the given `i` is a derivative builtin
-bool IsDerivativeBuiltin(BuiltinType i);
+bool IsDerivativeBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a texture operation builtin
 /// @param i the builtin type
 /// @returns true if the given `i` is a texture operation builtin
-bool IsTextureBuiltin(BuiltinType i);
+bool IsTextureBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a image query builtin
 /// @param i the builtin type
 /// @returns true if the given `i` is a image query builtin
-bool IsImageQueryBuiltin(BuiltinType i);
+bool IsImageQueryBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a data packing builtin
 /// @param i the builtin
 /// @returns true if the given `i` is a data packing builtin
-bool IsDataPackingBuiltin(BuiltinType i);
+bool IsDataPackingBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a data unpacking builtin
 /// @param i the builtin
 /// @returns true if the given `i` is a data unpacking builtin
-bool IsDataUnpackingBuiltin(BuiltinType i);
+bool IsDataUnpackingBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a barrier builtin
 /// @param i the builtin
 /// @returns true if the given `i` is a barrier builtin
-bool IsBarrierBuiltin(BuiltinType i);
+bool IsBarrierBuiltin(builtin::Function i);
 
 /// Determines if the given `i` is a atomic builtin
 /// @param i the builtin
 /// @returns true if the given `i` is a atomic builtin
-bool IsAtomicBuiltin(BuiltinType i);
+bool IsAtomicBuiltin(builtin::Function i);
 
 /// Determins if the given `i` is a DP4a builtin
 /// @param i the builtin
 /// @returns true if the given `i` is a DP4a builtin
-bool IsDP4aBuiltin(BuiltinType i);
+bool IsDP4aBuiltin(builtin::Function i);
 
 /// Builtin holds the semantic information for a builtin function.
 class Builtin final : public Castable<Builtin, CallTarget> {
@@ -87,7 +87,7 @@
     /// @param supported_stages the pipeline stages that this builtin can be used in
     /// @param is_deprecated true if the particular overload is considered deprecated
     /// @param must_use true if the builtin was annotated with `@must_use`
-    Builtin(BuiltinType type,
+    Builtin(builtin::Function type,
             const type::Type* return_type,
             utils::VectorRef<Parameter*> parameters,
             EvaluationStage eval_stage,
@@ -99,7 +99,7 @@
     ~Builtin() override;
 
     /// @return the type of the builtin
-    BuiltinType Type() const { return type_; }
+    builtin::Function Type() const { return type_; }
 
     /// @return the pipeline stages that this builtin can be used in
     PipelineStageSet SupportedStages() const { return supported_stages_; }
@@ -151,7 +151,7 @@
     builtin::Extension RequiredExtension() const;
 
   private:
-    const BuiltinType type_;
+    const builtin::Function type_;
     const PipelineStageSet supported_stages_;
     const bool is_deprecated_;
 };
diff --git a/src/tint/sem/builtin_test.cc b/src/tint/sem/builtin_test.cc
index ff66e1b..ef63dc6 100644
--- a/src/tint/sem/builtin_test.cc
+++ b/src/tint/sem/builtin_test.cc
@@ -21,7 +21,7 @@
 
 struct BuiltinData {
     const char* name;
-    BuiltinType builtin;
+    builtin::Function builtin;
 };
 
 inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
@@ -29,98 +29,98 @@
     return out;
 }
 
-using BuiltinTypeTest = testing::TestWithParam<BuiltinData>;
+using BuiltinFunctionTest = testing::TestWithParam<BuiltinData>;
 
-TEST_P(BuiltinTypeTest, Parse) {
+TEST_P(BuiltinFunctionTest, Parse) {
     auto param = GetParam();
-    EXPECT_EQ(ParseBuiltinType(param.name), param.builtin);
+    EXPECT_EQ(builtin::ParseFunction(param.name), param.builtin);
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    BuiltinTypeTest,
-    BuiltinTypeTest,
-    testing::Values(BuiltinData{"abs", BuiltinType::kAbs},
-                    BuiltinData{"acos", BuiltinType::kAcos},
-                    BuiltinData{"all", BuiltinType::kAll},
-                    BuiltinData{"any", BuiltinType::kAny},
-                    BuiltinData{"arrayLength", BuiltinType::kArrayLength},
-                    BuiltinData{"asin", BuiltinType::kAsin},
-                    BuiltinData{"atan", BuiltinType::kAtan},
-                    BuiltinData{"atan2", BuiltinType::kAtan2},
-                    BuiltinData{"ceil", BuiltinType::kCeil},
-                    BuiltinData{"clamp", BuiltinType::kClamp},
-                    BuiltinData{"cos", BuiltinType::kCos},
-                    BuiltinData{"cosh", BuiltinType::kCosh},
-                    BuiltinData{"countOneBits", BuiltinType::kCountOneBits},
-                    BuiltinData{"cross", BuiltinType::kCross},
-                    BuiltinData{"determinant", BuiltinType::kDeterminant},
-                    BuiltinData{"distance", BuiltinType::kDistance},
-                    BuiltinData{"dot", BuiltinType::kDot},
-                    BuiltinData{"dot4I8Packed", BuiltinType::kDot4I8Packed},
-                    BuiltinData{"dot4U8Packed", BuiltinType::kDot4U8Packed},
-                    BuiltinData{"dpdx", BuiltinType::kDpdx},
-                    BuiltinData{"dpdxCoarse", BuiltinType::kDpdxCoarse},
-                    BuiltinData{"dpdxFine", BuiltinType::kDpdxFine},
-                    BuiltinData{"dpdy", BuiltinType::kDpdy},
-                    BuiltinData{"dpdyCoarse", BuiltinType::kDpdyCoarse},
-                    BuiltinData{"dpdyFine", BuiltinType::kDpdyFine},
-                    BuiltinData{"exp", BuiltinType::kExp},
-                    BuiltinData{"exp2", BuiltinType::kExp2},
-                    BuiltinData{"faceForward", BuiltinType::kFaceForward},
-                    BuiltinData{"floor", BuiltinType::kFloor},
-                    BuiltinData{"fma", BuiltinType::kFma},
-                    BuiltinData{"fract", BuiltinType::kFract},
-                    BuiltinData{"frexp", BuiltinType::kFrexp},
-                    BuiltinData{"fwidth", BuiltinType::kFwidth},
-                    BuiltinData{"fwidthCoarse", BuiltinType::kFwidthCoarse},
-                    BuiltinData{"fwidthFine", BuiltinType::kFwidthFine},
-                    BuiltinData{"inverseSqrt", BuiltinType::kInverseSqrt},
-                    BuiltinData{"ldexp", BuiltinType::kLdexp},
-                    BuiltinData{"length", BuiltinType::kLength},
-                    BuiltinData{"log", BuiltinType::kLog},
-                    BuiltinData{"log2", BuiltinType::kLog2},
-                    BuiltinData{"max", BuiltinType::kMax},
-                    BuiltinData{"min", BuiltinType::kMin},
-                    BuiltinData{"mix", BuiltinType::kMix},
-                    BuiltinData{"modf", BuiltinType::kModf},
-                    BuiltinData{"normalize", BuiltinType::kNormalize},
-                    BuiltinData{"pow", BuiltinType::kPow},
-                    BuiltinData{"reflect", BuiltinType::kReflect},
-                    BuiltinData{"reverseBits", BuiltinType::kReverseBits},
-                    BuiltinData{"round", BuiltinType::kRound},
-                    BuiltinData{"select", BuiltinType::kSelect},
-                    BuiltinData{"sign", BuiltinType::kSign},
-                    BuiltinData{"sin", BuiltinType::kSin},
-                    BuiltinData{"sinh", BuiltinType::kSinh},
-                    BuiltinData{"smoothstep", BuiltinType::kSmoothstep},
-                    BuiltinData{"sqrt", BuiltinType::kSqrt},
-                    BuiltinData{"step", BuiltinType::kStep},
-                    BuiltinData{"storageBarrier", BuiltinType::kStorageBarrier},
-                    BuiltinData{"tan", BuiltinType::kTan},
-                    BuiltinData{"tanh", BuiltinType::kTanh},
-                    BuiltinData{"textureDimensions", BuiltinType::kTextureDimensions},
-                    BuiltinData{"textureLoad", BuiltinType::kTextureLoad},
-                    BuiltinData{"textureNumLayers", BuiltinType::kTextureNumLayers},
-                    BuiltinData{"textureNumLevels", BuiltinType::kTextureNumLevels},
-                    BuiltinData{"textureNumSamples", BuiltinType::kTextureNumSamples},
-                    BuiltinData{"textureSample", BuiltinType::kTextureSample},
-                    BuiltinData{"textureSampleBias", BuiltinType::kTextureSampleBias},
-                    BuiltinData{"textureSampleCompare", BuiltinType::kTextureSampleCompare},
+    BuiltinFunctionTest,
+    BuiltinFunctionTest,
+    testing::Values(BuiltinData{"abs", builtin::Function::kAbs},
+                    BuiltinData{"acos", builtin::Function::kAcos},
+                    BuiltinData{"all", builtin::Function::kAll},
+                    BuiltinData{"any", builtin::Function::kAny},
+                    BuiltinData{"arrayLength", builtin::Function::kArrayLength},
+                    BuiltinData{"asin", builtin::Function::kAsin},
+                    BuiltinData{"atan", builtin::Function::kAtan},
+                    BuiltinData{"atan2", builtin::Function::kAtan2},
+                    BuiltinData{"ceil", builtin::Function::kCeil},
+                    BuiltinData{"clamp", builtin::Function::kClamp},
+                    BuiltinData{"cos", builtin::Function::kCos},
+                    BuiltinData{"cosh", builtin::Function::kCosh},
+                    BuiltinData{"countOneBits", builtin::Function::kCountOneBits},
+                    BuiltinData{"cross", builtin::Function::kCross},
+                    BuiltinData{"determinant", builtin::Function::kDeterminant},
+                    BuiltinData{"distance", builtin::Function::kDistance},
+                    BuiltinData{"dot", builtin::Function::kDot},
+                    BuiltinData{"dot4I8Packed", builtin::Function::kDot4I8Packed},
+                    BuiltinData{"dot4U8Packed", builtin::Function::kDot4U8Packed},
+                    BuiltinData{"dpdx", builtin::Function::kDpdx},
+                    BuiltinData{"dpdxCoarse", builtin::Function::kDpdxCoarse},
+                    BuiltinData{"dpdxFine", builtin::Function::kDpdxFine},
+                    BuiltinData{"dpdy", builtin::Function::kDpdy},
+                    BuiltinData{"dpdyCoarse", builtin::Function::kDpdyCoarse},
+                    BuiltinData{"dpdyFine", builtin::Function::kDpdyFine},
+                    BuiltinData{"exp", builtin::Function::kExp},
+                    BuiltinData{"exp2", builtin::Function::kExp2},
+                    BuiltinData{"faceForward", builtin::Function::kFaceForward},
+                    BuiltinData{"floor", builtin::Function::kFloor},
+                    BuiltinData{"fma", builtin::Function::kFma},
+                    BuiltinData{"fract", builtin::Function::kFract},
+                    BuiltinData{"frexp", builtin::Function::kFrexp},
+                    BuiltinData{"fwidth", builtin::Function::kFwidth},
+                    BuiltinData{"fwidthCoarse", builtin::Function::kFwidthCoarse},
+                    BuiltinData{"fwidthFine", builtin::Function::kFwidthFine},
+                    BuiltinData{"inverseSqrt", builtin::Function::kInverseSqrt},
+                    BuiltinData{"ldexp", builtin::Function::kLdexp},
+                    BuiltinData{"length", builtin::Function::kLength},
+                    BuiltinData{"log", builtin::Function::kLog},
+                    BuiltinData{"log2", builtin::Function::kLog2},
+                    BuiltinData{"max", builtin::Function::kMax},
+                    BuiltinData{"min", builtin::Function::kMin},
+                    BuiltinData{"mix", builtin::Function::kMix},
+                    BuiltinData{"modf", builtin::Function::kModf},
+                    BuiltinData{"normalize", builtin::Function::kNormalize},
+                    BuiltinData{"pow", builtin::Function::kPow},
+                    BuiltinData{"reflect", builtin::Function::kReflect},
+                    BuiltinData{"reverseBits", builtin::Function::kReverseBits},
+                    BuiltinData{"round", builtin::Function::kRound},
+                    BuiltinData{"select", builtin::Function::kSelect},
+                    BuiltinData{"sign", builtin::Function::kSign},
+                    BuiltinData{"sin", builtin::Function::kSin},
+                    BuiltinData{"sinh", builtin::Function::kSinh},
+                    BuiltinData{"smoothstep", builtin::Function::kSmoothstep},
+                    BuiltinData{"sqrt", builtin::Function::kSqrt},
+                    BuiltinData{"step", builtin::Function::kStep},
+                    BuiltinData{"storageBarrier", builtin::Function::kStorageBarrier},
+                    BuiltinData{"tan", builtin::Function::kTan},
+                    BuiltinData{"tanh", builtin::Function::kTanh},
+                    BuiltinData{"textureDimensions", builtin::Function::kTextureDimensions},
+                    BuiltinData{"textureLoad", builtin::Function::kTextureLoad},
+                    BuiltinData{"textureNumLayers", builtin::Function::kTextureNumLayers},
+                    BuiltinData{"textureNumLevels", builtin::Function::kTextureNumLevels},
+                    BuiltinData{"textureNumSamples", builtin::Function::kTextureNumSamples},
+                    BuiltinData{"textureSample", builtin::Function::kTextureSample},
+                    BuiltinData{"textureSampleBias", builtin::Function::kTextureSampleBias},
+                    BuiltinData{"textureSampleCompare", builtin::Function::kTextureSampleCompare},
                     BuiltinData{"textureSampleCompareLevel",
-                                BuiltinType::kTextureSampleCompareLevel},
-                    BuiltinData{"textureSampleGrad", BuiltinType::kTextureSampleGrad},
-                    BuiltinData{"textureSampleLevel", BuiltinType::kTextureSampleLevel},
-                    BuiltinData{"trunc", BuiltinType::kTrunc},
-                    BuiltinData{"unpack2x16float", BuiltinType::kUnpack2X16Float},
-                    BuiltinData{"unpack2x16snorm", BuiltinType::kUnpack2X16Snorm},
-                    BuiltinData{"unpack2x16unorm", BuiltinType::kUnpack2X16Unorm},
-                    BuiltinData{"unpack4x8snorm", BuiltinType::kUnpack4X8Snorm},
-                    BuiltinData{"unpack4x8unorm", BuiltinType::kUnpack4X8Unorm},
-                    BuiltinData{"workgroupBarrier", BuiltinType::kWorkgroupBarrier},
-                    BuiltinData{"workgroupUniformLoad", BuiltinType::kWorkgroupUniformLoad}));
+                                builtin::Function::kTextureSampleCompareLevel},
+                    BuiltinData{"textureSampleGrad", builtin::Function::kTextureSampleGrad},
+                    BuiltinData{"textureSampleLevel", builtin::Function::kTextureSampleLevel},
+                    BuiltinData{"trunc", builtin::Function::kTrunc},
+                    BuiltinData{"unpack2x16float", builtin::Function::kUnpack2X16Float},
+                    BuiltinData{"unpack2x16snorm", builtin::Function::kUnpack2X16Snorm},
+                    BuiltinData{"unpack2x16unorm", builtin::Function::kUnpack2X16Unorm},
+                    BuiltinData{"unpack4x8snorm", builtin::Function::kUnpack4X8Snorm},
+                    BuiltinData{"unpack4x8unorm", builtin::Function::kUnpack4X8Unorm},
+                    BuiltinData{"workgroupBarrier", builtin::Function::kWorkgroupBarrier},
+                    BuiltinData{"workgroupUniformLoad", builtin::Function::kWorkgroupUniformLoad}));
 
-TEST_F(BuiltinTypeTest, ParseNoMatch) {
-    EXPECT_EQ(ParseBuiltinType("not_builtin"), BuiltinType::kNone);
+TEST_F(BuiltinFunctionTest, ParseNoMatch) {
+    EXPECT_EQ(builtin::ParseFunction("not_builtin"), builtin::Function::kNone);
 }
 
 }  // namespace
diff --git a/src/tint/sem/builtin_type.cc b/src/tint/sem/builtin_type.cc
deleted file mode 100644
index 8abcec0..0000000
--- a/src/tint/sem/builtin_type.cc
+++ /dev/null
@@ -1,614 +0,0 @@
-// Copyright 2021 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-////////////////////////////////////////////////////////////////////////////////
-// File generated by tools/src/cmd/gen
-// using the template:
-//   src/tint/sem/builtin_type.cc.tmpl
-//
-// Do not modify this file directly
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/tint/sem/builtin_type.h"
-
-namespace tint::sem {
-
-BuiltinType ParseBuiltinType(const std::string& name) {
-    if (name == "abs") {
-        return BuiltinType::kAbs;
-    }
-    if (name == "acos") {
-        return BuiltinType::kAcos;
-    }
-    if (name == "acosh") {
-        return BuiltinType::kAcosh;
-    }
-    if (name == "all") {
-        return BuiltinType::kAll;
-    }
-    if (name == "any") {
-        return BuiltinType::kAny;
-    }
-    if (name == "arrayLength") {
-        return BuiltinType::kArrayLength;
-    }
-    if (name == "asin") {
-        return BuiltinType::kAsin;
-    }
-    if (name == "asinh") {
-        return BuiltinType::kAsinh;
-    }
-    if (name == "atan") {
-        return BuiltinType::kAtan;
-    }
-    if (name == "atan2") {
-        return BuiltinType::kAtan2;
-    }
-    if (name == "atanh") {
-        return BuiltinType::kAtanh;
-    }
-    if (name == "ceil") {
-        return BuiltinType::kCeil;
-    }
-    if (name == "clamp") {
-        return BuiltinType::kClamp;
-    }
-    if (name == "cos") {
-        return BuiltinType::kCos;
-    }
-    if (name == "cosh") {
-        return BuiltinType::kCosh;
-    }
-    if (name == "countLeadingZeros") {
-        return BuiltinType::kCountLeadingZeros;
-    }
-    if (name == "countOneBits") {
-        return BuiltinType::kCountOneBits;
-    }
-    if (name == "countTrailingZeros") {
-        return BuiltinType::kCountTrailingZeros;
-    }
-    if (name == "cross") {
-        return BuiltinType::kCross;
-    }
-    if (name == "degrees") {
-        return BuiltinType::kDegrees;
-    }
-    if (name == "determinant") {
-        return BuiltinType::kDeterminant;
-    }
-    if (name == "distance") {
-        return BuiltinType::kDistance;
-    }
-    if (name == "dot") {
-        return BuiltinType::kDot;
-    }
-    if (name == "dot4I8Packed") {
-        return BuiltinType::kDot4I8Packed;
-    }
-    if (name == "dot4U8Packed") {
-        return BuiltinType::kDot4U8Packed;
-    }
-    if (name == "dpdx") {
-        return BuiltinType::kDpdx;
-    }
-    if (name == "dpdxCoarse") {
-        return BuiltinType::kDpdxCoarse;
-    }
-    if (name == "dpdxFine") {
-        return BuiltinType::kDpdxFine;
-    }
-    if (name == "dpdy") {
-        return BuiltinType::kDpdy;
-    }
-    if (name == "dpdyCoarse") {
-        return BuiltinType::kDpdyCoarse;
-    }
-    if (name == "dpdyFine") {
-        return BuiltinType::kDpdyFine;
-    }
-    if (name == "exp") {
-        return BuiltinType::kExp;
-    }
-    if (name == "exp2") {
-        return BuiltinType::kExp2;
-    }
-    if (name == "extractBits") {
-        return BuiltinType::kExtractBits;
-    }
-    if (name == "faceForward") {
-        return BuiltinType::kFaceForward;
-    }
-    if (name == "firstLeadingBit") {
-        return BuiltinType::kFirstLeadingBit;
-    }
-    if (name == "firstTrailingBit") {
-        return BuiltinType::kFirstTrailingBit;
-    }
-    if (name == "floor") {
-        return BuiltinType::kFloor;
-    }
-    if (name == "fma") {
-        return BuiltinType::kFma;
-    }
-    if (name == "fract") {
-        return BuiltinType::kFract;
-    }
-    if (name == "frexp") {
-        return BuiltinType::kFrexp;
-    }
-    if (name == "fwidth") {
-        return BuiltinType::kFwidth;
-    }
-    if (name == "fwidthCoarse") {
-        return BuiltinType::kFwidthCoarse;
-    }
-    if (name == "fwidthFine") {
-        return BuiltinType::kFwidthFine;
-    }
-    if (name == "insertBits") {
-        return BuiltinType::kInsertBits;
-    }
-    if (name == "inverseSqrt") {
-        return BuiltinType::kInverseSqrt;
-    }
-    if (name == "ldexp") {
-        return BuiltinType::kLdexp;
-    }
-    if (name == "length") {
-        return BuiltinType::kLength;
-    }
-    if (name == "log") {
-        return BuiltinType::kLog;
-    }
-    if (name == "log2") {
-        return BuiltinType::kLog2;
-    }
-    if (name == "max") {
-        return BuiltinType::kMax;
-    }
-    if (name == "min") {
-        return BuiltinType::kMin;
-    }
-    if (name == "mix") {
-        return BuiltinType::kMix;
-    }
-    if (name == "modf") {
-        return BuiltinType::kModf;
-    }
-    if (name == "normalize") {
-        return BuiltinType::kNormalize;
-    }
-    if (name == "pack2x16float") {
-        return BuiltinType::kPack2X16Float;
-    }
-    if (name == "pack2x16snorm") {
-        return BuiltinType::kPack2X16Snorm;
-    }
-    if (name == "pack2x16unorm") {
-        return BuiltinType::kPack2X16Unorm;
-    }
-    if (name == "pack4x8snorm") {
-        return BuiltinType::kPack4X8Snorm;
-    }
-    if (name == "pack4x8unorm") {
-        return BuiltinType::kPack4X8Unorm;
-    }
-    if (name == "pow") {
-        return BuiltinType::kPow;
-    }
-    if (name == "quantizeToF16") {
-        return BuiltinType::kQuantizeToF16;
-    }
-    if (name == "radians") {
-        return BuiltinType::kRadians;
-    }
-    if (name == "reflect") {
-        return BuiltinType::kReflect;
-    }
-    if (name == "refract") {
-        return BuiltinType::kRefract;
-    }
-    if (name == "reverseBits") {
-        return BuiltinType::kReverseBits;
-    }
-    if (name == "round") {
-        return BuiltinType::kRound;
-    }
-    if (name == "saturate") {
-        return BuiltinType::kSaturate;
-    }
-    if (name == "select") {
-        return BuiltinType::kSelect;
-    }
-    if (name == "sign") {
-        return BuiltinType::kSign;
-    }
-    if (name == "sin") {
-        return BuiltinType::kSin;
-    }
-    if (name == "sinh") {
-        return BuiltinType::kSinh;
-    }
-    if (name == "smoothstep") {
-        return BuiltinType::kSmoothstep;
-    }
-    if (name == "sqrt") {
-        return BuiltinType::kSqrt;
-    }
-    if (name == "step") {
-        return BuiltinType::kStep;
-    }
-    if (name == "storageBarrier") {
-        return BuiltinType::kStorageBarrier;
-    }
-    if (name == "tan") {
-        return BuiltinType::kTan;
-    }
-    if (name == "tanh") {
-        return BuiltinType::kTanh;
-    }
-    if (name == "transpose") {
-        return BuiltinType::kTranspose;
-    }
-    if (name == "trunc") {
-        return BuiltinType::kTrunc;
-    }
-    if (name == "unpack2x16float") {
-        return BuiltinType::kUnpack2X16Float;
-    }
-    if (name == "unpack2x16snorm") {
-        return BuiltinType::kUnpack2X16Snorm;
-    }
-    if (name == "unpack2x16unorm") {
-        return BuiltinType::kUnpack2X16Unorm;
-    }
-    if (name == "unpack4x8snorm") {
-        return BuiltinType::kUnpack4X8Snorm;
-    }
-    if (name == "unpack4x8unorm") {
-        return BuiltinType::kUnpack4X8Unorm;
-    }
-    if (name == "workgroupBarrier") {
-        return BuiltinType::kWorkgroupBarrier;
-    }
-    if (name == "workgroupUniformLoad") {
-        return BuiltinType::kWorkgroupUniformLoad;
-    }
-    if (name == "textureDimensions") {
-        return BuiltinType::kTextureDimensions;
-    }
-    if (name == "textureGather") {
-        return BuiltinType::kTextureGather;
-    }
-    if (name == "textureGatherCompare") {
-        return BuiltinType::kTextureGatherCompare;
-    }
-    if (name == "textureNumLayers") {
-        return BuiltinType::kTextureNumLayers;
-    }
-    if (name == "textureNumLevels") {
-        return BuiltinType::kTextureNumLevels;
-    }
-    if (name == "textureNumSamples") {
-        return BuiltinType::kTextureNumSamples;
-    }
-    if (name == "textureSample") {
-        return BuiltinType::kTextureSample;
-    }
-    if (name == "textureSampleBias") {
-        return BuiltinType::kTextureSampleBias;
-    }
-    if (name == "textureSampleCompare") {
-        return BuiltinType::kTextureSampleCompare;
-    }
-    if (name == "textureSampleCompareLevel") {
-        return BuiltinType::kTextureSampleCompareLevel;
-    }
-    if (name == "textureSampleGrad") {
-        return BuiltinType::kTextureSampleGrad;
-    }
-    if (name == "textureSampleLevel") {
-        return BuiltinType::kTextureSampleLevel;
-    }
-    if (name == "textureSampleBaseClampToEdge") {
-        return BuiltinType::kTextureSampleBaseClampToEdge;
-    }
-    if (name == "textureStore") {
-        return BuiltinType::kTextureStore;
-    }
-    if (name == "textureLoad") {
-        return BuiltinType::kTextureLoad;
-    }
-    if (name == "atomicLoad") {
-        return BuiltinType::kAtomicLoad;
-    }
-    if (name == "atomicStore") {
-        return BuiltinType::kAtomicStore;
-    }
-    if (name == "atomicAdd") {
-        return BuiltinType::kAtomicAdd;
-    }
-    if (name == "atomicSub") {
-        return BuiltinType::kAtomicSub;
-    }
-    if (name == "atomicMax") {
-        return BuiltinType::kAtomicMax;
-    }
-    if (name == "atomicMin") {
-        return BuiltinType::kAtomicMin;
-    }
-    if (name == "atomicAnd") {
-        return BuiltinType::kAtomicAnd;
-    }
-    if (name == "atomicOr") {
-        return BuiltinType::kAtomicOr;
-    }
-    if (name == "atomicXor") {
-        return BuiltinType::kAtomicXor;
-    }
-    if (name == "atomicExchange") {
-        return BuiltinType::kAtomicExchange;
-    }
-    if (name == "atomicCompareExchangeWeak") {
-        return BuiltinType::kAtomicCompareExchangeWeak;
-    }
-    if (name == "_tint_materialize") {
-        return BuiltinType::kTintMaterialize;
-    }
-    return BuiltinType::kNone;
-}
-
-const char* str(BuiltinType i) {
-    switch (i) {
-        case BuiltinType::kNone:
-            return "<none>";
-        case BuiltinType::kAbs:
-            return "abs";
-        case BuiltinType::kAcos:
-            return "acos";
-        case BuiltinType::kAcosh:
-            return "acosh";
-        case BuiltinType::kAll:
-            return "all";
-        case BuiltinType::kAny:
-            return "any";
-        case BuiltinType::kArrayLength:
-            return "arrayLength";
-        case BuiltinType::kAsin:
-            return "asin";
-        case BuiltinType::kAsinh:
-            return "asinh";
-        case BuiltinType::kAtan:
-            return "atan";
-        case BuiltinType::kAtan2:
-            return "atan2";
-        case BuiltinType::kAtanh:
-            return "atanh";
-        case BuiltinType::kCeil:
-            return "ceil";
-        case BuiltinType::kClamp:
-            return "clamp";
-        case BuiltinType::kCos:
-            return "cos";
-        case BuiltinType::kCosh:
-            return "cosh";
-        case BuiltinType::kCountLeadingZeros:
-            return "countLeadingZeros";
-        case BuiltinType::kCountOneBits:
-            return "countOneBits";
-        case BuiltinType::kCountTrailingZeros:
-            return "countTrailingZeros";
-        case BuiltinType::kCross:
-            return "cross";
-        case BuiltinType::kDegrees:
-            return "degrees";
-        case BuiltinType::kDeterminant:
-            return "determinant";
-        case BuiltinType::kDistance:
-            return "distance";
-        case BuiltinType::kDot:
-            return "dot";
-        case BuiltinType::kDot4I8Packed:
-            return "dot4I8Packed";
-        case BuiltinType::kDot4U8Packed:
-            return "dot4U8Packed";
-        case BuiltinType::kDpdx:
-            return "dpdx";
-        case BuiltinType::kDpdxCoarse:
-            return "dpdxCoarse";
-        case BuiltinType::kDpdxFine:
-            return "dpdxFine";
-        case BuiltinType::kDpdy:
-            return "dpdy";
-        case BuiltinType::kDpdyCoarse:
-            return "dpdyCoarse";
-        case BuiltinType::kDpdyFine:
-            return "dpdyFine";
-        case BuiltinType::kExp:
-            return "exp";
-        case BuiltinType::kExp2:
-            return "exp2";
-        case BuiltinType::kExtractBits:
-            return "extractBits";
-        case BuiltinType::kFaceForward:
-            return "faceForward";
-        case BuiltinType::kFirstLeadingBit:
-            return "firstLeadingBit";
-        case BuiltinType::kFirstTrailingBit:
-            return "firstTrailingBit";
-        case BuiltinType::kFloor:
-            return "floor";
-        case BuiltinType::kFma:
-            return "fma";
-        case BuiltinType::kFract:
-            return "fract";
-        case BuiltinType::kFrexp:
-            return "frexp";
-        case BuiltinType::kFwidth:
-            return "fwidth";
-        case BuiltinType::kFwidthCoarse:
-            return "fwidthCoarse";
-        case BuiltinType::kFwidthFine:
-            return "fwidthFine";
-        case BuiltinType::kInsertBits:
-            return "insertBits";
-        case BuiltinType::kInverseSqrt:
-            return "inverseSqrt";
-        case BuiltinType::kLdexp:
-            return "ldexp";
-        case BuiltinType::kLength:
-            return "length";
-        case BuiltinType::kLog:
-            return "log";
-        case BuiltinType::kLog2:
-            return "log2";
-        case BuiltinType::kMax:
-            return "max";
-        case BuiltinType::kMin:
-            return "min";
-        case BuiltinType::kMix:
-            return "mix";
-        case BuiltinType::kModf:
-            return "modf";
-        case BuiltinType::kNormalize:
-            return "normalize";
-        case BuiltinType::kPack2X16Float:
-            return "pack2x16float";
-        case BuiltinType::kPack2X16Snorm:
-            return "pack2x16snorm";
-        case BuiltinType::kPack2X16Unorm:
-            return "pack2x16unorm";
-        case BuiltinType::kPack4X8Snorm:
-            return "pack4x8snorm";
-        case BuiltinType::kPack4X8Unorm:
-            return "pack4x8unorm";
-        case BuiltinType::kPow:
-            return "pow";
-        case BuiltinType::kQuantizeToF16:
-            return "quantizeToF16";
-        case BuiltinType::kRadians:
-            return "radians";
-        case BuiltinType::kReflect:
-            return "reflect";
-        case BuiltinType::kRefract:
-            return "refract";
-        case BuiltinType::kReverseBits:
-            return "reverseBits";
-        case BuiltinType::kRound:
-            return "round";
-        case BuiltinType::kSaturate:
-            return "saturate";
-        case BuiltinType::kSelect:
-            return "select";
-        case BuiltinType::kSign:
-            return "sign";
-        case BuiltinType::kSin:
-            return "sin";
-        case BuiltinType::kSinh:
-            return "sinh";
-        case BuiltinType::kSmoothstep:
-            return "smoothstep";
-        case BuiltinType::kSqrt:
-            return "sqrt";
-        case BuiltinType::kStep:
-            return "step";
-        case BuiltinType::kStorageBarrier:
-            return "storageBarrier";
-        case BuiltinType::kTan:
-            return "tan";
-        case BuiltinType::kTanh:
-            return "tanh";
-        case BuiltinType::kTranspose:
-            return "transpose";
-        case BuiltinType::kTrunc:
-            return "trunc";
-        case BuiltinType::kUnpack2X16Float:
-            return "unpack2x16float";
-        case BuiltinType::kUnpack2X16Snorm:
-            return "unpack2x16snorm";
-        case BuiltinType::kUnpack2X16Unorm:
-            return "unpack2x16unorm";
-        case BuiltinType::kUnpack4X8Snorm:
-            return "unpack4x8snorm";
-        case BuiltinType::kUnpack4X8Unorm:
-            return "unpack4x8unorm";
-        case BuiltinType::kWorkgroupBarrier:
-            return "workgroupBarrier";
-        case BuiltinType::kWorkgroupUniformLoad:
-            return "workgroupUniformLoad";
-        case BuiltinType::kTextureDimensions:
-            return "textureDimensions";
-        case BuiltinType::kTextureGather:
-            return "textureGather";
-        case BuiltinType::kTextureGatherCompare:
-            return "textureGatherCompare";
-        case BuiltinType::kTextureNumLayers:
-            return "textureNumLayers";
-        case BuiltinType::kTextureNumLevels:
-            return "textureNumLevels";
-        case BuiltinType::kTextureNumSamples:
-            return "textureNumSamples";
-        case BuiltinType::kTextureSample:
-            return "textureSample";
-        case BuiltinType::kTextureSampleBias:
-            return "textureSampleBias";
-        case BuiltinType::kTextureSampleCompare:
-            return "textureSampleCompare";
-        case BuiltinType::kTextureSampleCompareLevel:
-            return "textureSampleCompareLevel";
-        case BuiltinType::kTextureSampleGrad:
-            return "textureSampleGrad";
-        case BuiltinType::kTextureSampleLevel:
-            return "textureSampleLevel";
-        case BuiltinType::kTextureSampleBaseClampToEdge:
-            return "textureSampleBaseClampToEdge";
-        case BuiltinType::kTextureStore:
-            return "textureStore";
-        case BuiltinType::kTextureLoad:
-            return "textureLoad";
-        case BuiltinType::kAtomicLoad:
-            return "atomicLoad";
-        case BuiltinType::kAtomicStore:
-            return "atomicStore";
-        case BuiltinType::kAtomicAdd:
-            return "atomicAdd";
-        case BuiltinType::kAtomicSub:
-            return "atomicSub";
-        case BuiltinType::kAtomicMax:
-            return "atomicMax";
-        case BuiltinType::kAtomicMin:
-            return "atomicMin";
-        case BuiltinType::kAtomicAnd:
-            return "atomicAnd";
-        case BuiltinType::kAtomicOr:
-            return "atomicOr";
-        case BuiltinType::kAtomicXor:
-            return "atomicXor";
-        case BuiltinType::kAtomicExchange:
-            return "atomicExchange";
-        case BuiltinType::kAtomicCompareExchangeWeak:
-            return "atomicCompareExchangeWeak";
-        case BuiltinType::kTintMaterialize:
-            return "_tint_materialize";
-    }
-    return "<unknown>";
-}
-
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i) {
-    out << str(i);
-    return out;
-}
-
-}  // namespace tint::sem
diff --git a/src/tint/sem/builtin_type.cc.tmpl b/src/tint/sem/builtin_type.cc.tmpl
deleted file mode 100644
index 86a8623..0000000
--- a/src/tint/sem/builtin_type.cc.tmpl
+++ /dev/null
@@ -1,44 +0,0 @@
-{{- /*
---------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate builtin_type.cc
-
-To update the generated file, run:
-    ./tools/run gen
-
-See:
-* tools/src/cmd/gen for structures used by this template
-* https://golang.org/pkg/text/template/ for documentation on the template syntax
---------------------------------------------------------------------------------
-*/ -}}
-
-#include "src/tint/sem/builtin_type.h"
-
-namespace tint::sem {
-
-BuiltinType ParseBuiltinType(const std::string& name) {
-{{- range Sem.Builtins  }}
-    if (name == "{{.Name}}") {
-        return BuiltinType::k{{PascalCase .Name}};
-    }
-{{- end  }}
-    return BuiltinType::kNone;
-}
-
-const char* str(BuiltinType i) {
-    switch (i) {
-        case BuiltinType::kNone:
-            return "<none>";
-{{- range Sem.Builtins  }}
-        case BuiltinType::k{{PascalCase .Name}}:
-            return "{{.Name}}";
-{{- end  }}
-    }
-    return "<unknown>";
-}
-
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i) {
-    out << str(i);
-    return out;
-}
-
-}  // namespace tint::sem
diff --git a/src/tint/sem/builtin_type.h b/src/tint/sem/builtin_type.h
deleted file mode 100644
index 23f3749..0000000
--- a/src/tint/sem/builtin_type.h
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright 2021 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-////////////////////////////////////////////////////////////////////////////////
-// File generated by tools/src/cmd/gen
-// using the template:
-//   src/tint/sem/builtin_type.h.tmpl
-//
-// Do not modify this file directly
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef SRC_TINT_SEM_BUILTIN_TYPE_H_
-#define SRC_TINT_SEM_BUILTIN_TYPE_H_
-
-#include <string>
-
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::sem {
-
-/// Enumerator of all builtin functions
-enum class BuiltinType {
-    kNone = -1,
-    kAbs,
-    kAcos,
-    kAcosh,
-    kAll,
-    kAny,
-    kArrayLength,
-    kAsin,
-    kAsinh,
-    kAtan,
-    kAtan2,
-    kAtanh,
-    kCeil,
-    kClamp,
-    kCos,
-    kCosh,
-    kCountLeadingZeros,
-    kCountOneBits,
-    kCountTrailingZeros,
-    kCross,
-    kDegrees,
-    kDeterminant,
-    kDistance,
-    kDot,
-    kDot4I8Packed,
-    kDot4U8Packed,
-    kDpdx,
-    kDpdxCoarse,
-    kDpdxFine,
-    kDpdy,
-    kDpdyCoarse,
-    kDpdyFine,
-    kExp,
-    kExp2,
-    kExtractBits,
-    kFaceForward,
-    kFirstLeadingBit,
-    kFirstTrailingBit,
-    kFloor,
-    kFma,
-    kFract,
-    kFrexp,
-    kFwidth,
-    kFwidthCoarse,
-    kFwidthFine,
-    kInsertBits,
-    kInverseSqrt,
-    kLdexp,
-    kLength,
-    kLog,
-    kLog2,
-    kMax,
-    kMin,
-    kMix,
-    kModf,
-    kNormalize,
-    kPack2X16Float,
-    kPack2X16Snorm,
-    kPack2X16Unorm,
-    kPack4X8Snorm,
-    kPack4X8Unorm,
-    kPow,
-    kQuantizeToF16,
-    kRadians,
-    kReflect,
-    kRefract,
-    kReverseBits,
-    kRound,
-    kSaturate,
-    kSelect,
-    kSign,
-    kSin,
-    kSinh,
-    kSmoothstep,
-    kSqrt,
-    kStep,
-    kStorageBarrier,
-    kTan,
-    kTanh,
-    kTranspose,
-    kTrunc,
-    kUnpack2X16Float,
-    kUnpack2X16Snorm,
-    kUnpack2X16Unorm,
-    kUnpack4X8Snorm,
-    kUnpack4X8Unorm,
-    kWorkgroupBarrier,
-    kWorkgroupUniformLoad,
-    kTextureDimensions,
-    kTextureGather,
-    kTextureGatherCompare,
-    kTextureNumLayers,
-    kTextureNumLevels,
-    kTextureNumSamples,
-    kTextureSample,
-    kTextureSampleBias,
-    kTextureSampleCompare,
-    kTextureSampleCompareLevel,
-    kTextureSampleGrad,
-    kTextureSampleLevel,
-    kTextureSampleBaseClampToEdge,
-    kTextureStore,
-    kTextureLoad,
-    kAtomicLoad,
-    kAtomicStore,
-    kAtomicAdd,
-    kAtomicSub,
-    kAtomicMax,
-    kAtomicMin,
-    kAtomicAnd,
-    kAtomicOr,
-    kAtomicXor,
-    kAtomicExchange,
-    kAtomicCompareExchangeWeak,
-    kTintMaterialize,
-};
-
-/// Matches the BuiltinType by name
-/// @param name the builtin name to parse
-/// @returns the parsed BuiltinType, or BuiltinType::kNone if `name` did not
-/// match any builtin.
-BuiltinType ParseBuiltinType(const std::string& name);
-
-/// @returns the name of the builtin function type. The spelling, including
-/// case, matches the name in the WGSL spec.
-const char* str(BuiltinType i);
-
-/// Emits the name of the builtin function type. The spelling, including case,
-/// matches the name in the WGSL spec.
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i);
-
-/// All builtin function
-constexpr BuiltinType kBuiltinTypes[] = {
-    BuiltinType::kAbs,
-    BuiltinType::kAcos,
-    BuiltinType::kAcosh,
-    BuiltinType::kAll,
-    BuiltinType::kAny,
-    BuiltinType::kArrayLength,
-    BuiltinType::kAsin,
-    BuiltinType::kAsinh,
-    BuiltinType::kAtan,
-    BuiltinType::kAtan2,
-    BuiltinType::kAtanh,
-    BuiltinType::kCeil,
-    BuiltinType::kClamp,
-    BuiltinType::kCos,
-    BuiltinType::kCosh,
-    BuiltinType::kCountLeadingZeros,
-    BuiltinType::kCountOneBits,
-    BuiltinType::kCountTrailingZeros,
-    BuiltinType::kCross,
-    BuiltinType::kDegrees,
-    BuiltinType::kDeterminant,
-    BuiltinType::kDistance,
-    BuiltinType::kDot,
-    BuiltinType::kDot4I8Packed,
-    BuiltinType::kDot4U8Packed,
-    BuiltinType::kDpdx,
-    BuiltinType::kDpdxCoarse,
-    BuiltinType::kDpdxFine,
-    BuiltinType::kDpdy,
-    BuiltinType::kDpdyCoarse,
-    BuiltinType::kDpdyFine,
-    BuiltinType::kExp,
-    BuiltinType::kExp2,
-    BuiltinType::kExtractBits,
-    BuiltinType::kFaceForward,
-    BuiltinType::kFirstLeadingBit,
-    BuiltinType::kFirstTrailingBit,
-    BuiltinType::kFloor,
-    BuiltinType::kFma,
-    BuiltinType::kFract,
-    BuiltinType::kFrexp,
-    BuiltinType::kFwidth,
-    BuiltinType::kFwidthCoarse,
-    BuiltinType::kFwidthFine,
-    BuiltinType::kInsertBits,
-    BuiltinType::kInverseSqrt,
-    BuiltinType::kLdexp,
-    BuiltinType::kLength,
-    BuiltinType::kLog,
-    BuiltinType::kLog2,
-    BuiltinType::kMax,
-    BuiltinType::kMin,
-    BuiltinType::kMix,
-    BuiltinType::kModf,
-    BuiltinType::kNormalize,
-    BuiltinType::kPack2X16Float,
-    BuiltinType::kPack2X16Snorm,
-    BuiltinType::kPack2X16Unorm,
-    BuiltinType::kPack4X8Snorm,
-    BuiltinType::kPack4X8Unorm,
-    BuiltinType::kPow,
-    BuiltinType::kQuantizeToF16,
-    BuiltinType::kRadians,
-    BuiltinType::kReflect,
-    BuiltinType::kRefract,
-    BuiltinType::kReverseBits,
-    BuiltinType::kRound,
-    BuiltinType::kSaturate,
-    BuiltinType::kSelect,
-    BuiltinType::kSign,
-    BuiltinType::kSin,
-    BuiltinType::kSinh,
-    BuiltinType::kSmoothstep,
-    BuiltinType::kSqrt,
-    BuiltinType::kStep,
-    BuiltinType::kStorageBarrier,
-    BuiltinType::kTan,
-    BuiltinType::kTanh,
-    BuiltinType::kTranspose,
-    BuiltinType::kTrunc,
-    BuiltinType::kUnpack2X16Float,
-    BuiltinType::kUnpack2X16Snorm,
-    BuiltinType::kUnpack2X16Unorm,
-    BuiltinType::kUnpack4X8Snorm,
-    BuiltinType::kUnpack4X8Unorm,
-    BuiltinType::kWorkgroupBarrier,
-    BuiltinType::kWorkgroupUniformLoad,
-    BuiltinType::kTextureDimensions,
-    BuiltinType::kTextureGather,
-    BuiltinType::kTextureGatherCompare,
-    BuiltinType::kTextureNumLayers,
-    BuiltinType::kTextureNumLevels,
-    BuiltinType::kTextureNumSamples,
-    BuiltinType::kTextureSample,
-    BuiltinType::kTextureSampleBias,
-    BuiltinType::kTextureSampleCompare,
-    BuiltinType::kTextureSampleCompareLevel,
-    BuiltinType::kTextureSampleGrad,
-    BuiltinType::kTextureSampleLevel,
-    BuiltinType::kTextureSampleBaseClampToEdge,
-    BuiltinType::kTextureStore,
-    BuiltinType::kTextureLoad,
-    BuiltinType::kAtomicLoad,
-    BuiltinType::kAtomicStore,
-    BuiltinType::kAtomicAdd,
-    BuiltinType::kAtomicSub,
-    BuiltinType::kAtomicMax,
-    BuiltinType::kAtomicMin,
-    BuiltinType::kAtomicAnd,
-    BuiltinType::kAtomicOr,
-    BuiltinType::kAtomicXor,
-    BuiltinType::kAtomicExchange,
-    BuiltinType::kAtomicCompareExchangeWeak,
-    BuiltinType::kTintMaterialize,
-};
-
-/// All builtin function names
-constexpr const char* kBuiltinStrings[] = {
-    "abs",
-    "acos",
-    "acosh",
-    "all",
-    "any",
-    "arrayLength",
-    "asin",
-    "asinh",
-    "atan",
-    "atan2",
-    "atanh",
-    "ceil",
-    "clamp",
-    "cos",
-    "cosh",
-    "countLeadingZeros",
-    "countOneBits",
-    "countTrailingZeros",
-    "cross",
-    "degrees",
-    "determinant",
-    "distance",
-    "dot",
-    "dot4I8Packed",
-    "dot4U8Packed",
-    "dpdx",
-    "dpdxCoarse",
-    "dpdxFine",
-    "dpdy",
-    "dpdyCoarse",
-    "dpdyFine",
-    "exp",
-    "exp2",
-    "extractBits",
-    "faceForward",
-    "firstLeadingBit",
-    "firstTrailingBit",
-    "floor",
-    "fma",
-    "fract",
-    "frexp",
-    "fwidth",
-    "fwidthCoarse",
-    "fwidthFine",
-    "insertBits",
-    "inverseSqrt",
-    "ldexp",
-    "length",
-    "log",
-    "log2",
-    "max",
-    "min",
-    "mix",
-    "modf",
-    "normalize",
-    "pack2x16float",
-    "pack2x16snorm",
-    "pack2x16unorm",
-    "pack4x8snorm",
-    "pack4x8unorm",
-    "pow",
-    "quantizeToF16",
-    "radians",
-    "reflect",
-    "refract",
-    "reverseBits",
-    "round",
-    "saturate",
-    "select",
-    "sign",
-    "sin",
-    "sinh",
-    "smoothstep",
-    "sqrt",
-    "step",
-    "storageBarrier",
-    "tan",
-    "tanh",
-    "transpose",
-    "trunc",
-    "unpack2x16float",
-    "unpack2x16snorm",
-    "unpack2x16unorm",
-    "unpack4x8snorm",
-    "unpack4x8unorm",
-    "workgroupBarrier",
-    "workgroupUniformLoad",
-    "textureDimensions",
-    "textureGather",
-    "textureGatherCompare",
-    "textureNumLayers",
-    "textureNumLevels",
-    "textureNumSamples",
-    "textureSample",
-    "textureSampleBias",
-    "textureSampleCompare",
-    "textureSampleCompareLevel",
-    "textureSampleGrad",
-    "textureSampleLevel",
-    "textureSampleBaseClampToEdge",
-    "textureStore",
-    "textureLoad",
-    "atomicLoad",
-    "atomicStore",
-    "atomicAdd",
-    "atomicSub",
-    "atomicMax",
-    "atomicMin",
-    "atomicAnd",
-    "atomicOr",
-    "atomicXor",
-    "atomicExchange",
-    "atomicCompareExchangeWeak",
-    "_tint_materialize",
-};
-
-}  // namespace tint::sem
-
-#endif  // SRC_TINT_SEM_BUILTIN_TYPE_H_
diff --git a/src/tint/sem/builtin_type.h.tmpl b/src/tint/sem/builtin_type.h.tmpl
deleted file mode 100644
index 366db95..0000000
--- a/src/tint/sem/builtin_type.h.tmpl
+++ /dev/null
@@ -1,61 +0,0 @@
-{{- /*
---------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate builtin_type.h
-
-To update the generated file, run:
-    ./tools/run gen
-
-See:
-* tools/src/cmd/gen for structures used by this template
-* https://golang.org/pkg/text/template/ for documentation on the template syntax
---------------------------------------------------------------------------------
-*/ -}}
-
-#ifndef SRC_TINT_SEM_BUILTIN_TYPE_H_
-#define SRC_TINT_SEM_BUILTIN_TYPE_H_
-
-#include <string>
-
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::sem {
-
-/// Enumerator of all builtin functions
-enum class BuiltinType {
-    kNone = -1,
-{{- range Sem.Builtins }}
-    k{{PascalCase .Name}},
-{{- end }}
-};
-
-/// Matches the BuiltinType by name
-/// @param name the builtin name to parse
-/// @returns the parsed BuiltinType, or BuiltinType::kNone if `name` did not
-/// match any builtin.
-BuiltinType ParseBuiltinType(const std::string& name);
-
-/// @returns the name of the builtin function type. The spelling, including
-/// case, matches the name in the WGSL spec.
-const char* str(BuiltinType i);
-
-/// Emits the name of the builtin function type. The spelling, including case,
-/// matches the name in the WGSL spec.
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i);
-
-/// All builtin function
-constexpr BuiltinType kBuiltinTypes[] = {
-{{- range Sem.Builtins }}
-    BuiltinType::k{{PascalCase .Name}},
-{{- end }}
-};
-
-/// All builtin function names
-constexpr const char* kBuiltinStrings[] = {
-{{- range Sem.Builtins }}
-    "{{.Name}}",
-{{- end }}
-};
-
-}  // namespace tint::sem
-
-#endif  // SRC_TINT_SEM_BUILTIN_TYPE_H_
diff --git a/src/tint/sem/diagnostic_severity_test.cc b/src/tint/sem/diagnostic_severity_test.cc
index fa57b55..a22b43e 100644
--- a/src/tint/sem/diagnostic_severity_test.cc
+++ b/src/tint/sem/diagnostic_severity_test.cc
@@ -31,45 +31,121 @@
         // @diagnostic(off, chromium_unreachable_code)
         // fn foo() {
         //   @diagnostic(info, chromium_unreachable_code) {
+        //     @diagnostic(error, chromium_unreachable_code)
         //     if (true) @diagnostic(warning, chromium_unreachable_code) {
         //       return;
+        //     } else if (false) {
+        //       return;
+        //     } else @diagnostic(info, chromium_unreachable_code) {
+        //       return;
+        //     }
+        //     return;
+        //
+        //     @diagnostic(error, chromium_unreachable_code)
+        //     switch (42) {
+        //       case 0 @diagnostic(warning, chromium_unreachable_code) {
+        //         return;
+        //       }
+        //       default {
+        //         return;
+        //       }
+        //     }
+        //
+        //     @diagnostic(error, chromium_unreachable_code)
+        //     for (var i = 0; false; i++) @diagnostic(warning, chromium_unreachable_code) {
+        //       return;
+        //     }
+        //   }
+        //
+        //     @diagnostic(error, chromium_unreachable_code)
+        //     while (false) @diagnostic(warning, chromium_unreachable_code) {
+        //       return;
         //     }
         //   }
         // }
         //
         // fn bar() {
-        //   {
-        //     if (true) {
-        //       return;
-        //     }
-        //   }
+        //   return;
         // }
         auto rule = builtin::DiagnosticRule::kChromiumUnreachableCode;
         auto func_severity = builtin::DiagnosticSeverity::kOff;
         auto block_severity = builtin::DiagnosticSeverity::kInfo;
-        auto if_severity = builtin::DiagnosticSeverity::kInfo;
+        auto if_severity = builtin::DiagnosticSeverity::kError;
+        auto if_body_severity = builtin::DiagnosticSeverity::kWarning;
+        auto else_body_severity = builtin::DiagnosticSeverity::kInfo;
+        auto switch_severity = builtin::DiagnosticSeverity::kError;
+        auto case_severity = builtin::DiagnosticSeverity::kWarning;
+        auto for_severity = builtin::DiagnosticSeverity::kError;
+        auto for_body_severity = builtin::DiagnosticSeverity::kWarning;
+        auto while_severity = builtin::DiagnosticSeverity::kError;
+        auto while_body_severity = builtin::DiagnosticSeverity::kWarning;
         auto attr = [&](auto severity) {
             return utils::Vector{DiagnosticAttribute(severity, "chromium_unreachable_code")};
         };
 
-        auto* return_1 = Return();
-        auto* if_1 = If(Expr(true), Block(utils::Vector{return_1}, attr(if_severity)));
-        auto* block_1 = Block(utils::Vector{if_1}, attr(block_severity));
+        auto* return_foo_if = Return();
+        auto* return_foo_elseif = Return();
+        auto* return_foo_else = Return();
+        auto* return_foo_block = Return();
+        auto* return_foo_case = Return();
+        auto* return_foo_default = Return();
+        auto* return_foo_for = Return();
+        auto* return_foo_while = Return();
+        auto* else_stmt = Block(utils::Vector{return_foo_else}, attr(else_body_severity));
+        auto* elseif = If(Expr(false), Block(return_foo_elseif), Else(else_stmt));
+        auto* if_foo = If(Expr(true), Block(utils::Vector{return_foo_if}, attr(if_body_severity)),
+                          Else(elseif), attr(if_severity));
+        auto* case_stmt =
+            Case(CaseSelector(0_a), Block(utils::Vector{return_foo_case}, attr(case_severity)));
+        auto* swtch = Switch(42_a, utils::Vector{case_stmt, DefaultCase(Block(return_foo_default))},
+                             attr(switch_severity));
+        auto* fl =
+            For(Decl(Var("i", ty.i32())), false, Increment("i"),
+                Block(utils::Vector{return_foo_for}, attr(for_body_severity)), attr(for_severity));
+        auto* wl = While(false, Block(utils::Vector{return_foo_while}, attr(while_body_severity)),
+                         attr(while_severity));
+        auto* block_1 =
+            Block(utils::Vector{if_foo, return_foo_block, swtch, fl, wl}, attr(block_severity));
         auto* func_attr = DiagnosticAttribute(func_severity, "chromium_unreachable_code");
         auto* foo = Func("foo", {}, ty.void_(), utils::Vector{block_1}, utils::Vector{func_attr});
 
-        auto* return_2 = Return();
-        auto* bar = Func("bar", {}, ty.void_(), utils::Vector{return_2});
+        auto* return_bar = Return();
+        auto* bar = Func("bar", {}, ty.void_(), utils::Vector{return_bar});
 
         auto p = Build();
         EXPECT_TRUE(p.IsValid()) << p.Diagnostics().str();
 
         EXPECT_EQ(p.Sem().DiagnosticSeverity(foo, rule), func_severity);
         EXPECT_EQ(p.Sem().DiagnosticSeverity(block_1, rule), block_severity);
-        EXPECT_EQ(p.Sem().DiagnosticSeverity(if_1, rule), block_severity);
-        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_1, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(if_foo, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(if_foo->condition, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(if_foo->body, rule), if_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_if, rule), if_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(elseif, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(elseif->condition, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(elseif->body, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_elseif, rule), if_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(else_stmt, rule), else_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_else, rule), else_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(swtch, rule), switch_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(swtch->condition, rule), switch_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(case_stmt, rule), switch_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(case_stmt->body, rule), case_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_case, rule), case_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_default, rule), switch_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(fl, rule), while_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(fl->initializer, rule), for_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(fl->condition, rule), for_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(fl->continuing, rule), for_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(fl->body, rule), for_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_for, rule), for_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(wl, rule), while_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(wl->condition, rule), while_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(wl->body, rule), while_body_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_foo_while, rule), while_body_severity);
+
         EXPECT_EQ(p.Sem().DiagnosticSeverity(bar, rule), global_severity);
-        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_2, rule), global_severity);
+        EXPECT_EQ(p.Sem().DiagnosticSeverity(return_bar, rule), global_severity);
     }
 };
 
diff --git a/src/tint/sem/external_texture.h b/src/tint/sem/external_texture.h
new file mode 100644
index 0000000..2ad5673
--- /dev/null
+++ b/src/tint/sem/external_texture.h
@@ -0,0 +1,45 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_SEM_EXTERNAL_TEXTURE_H_
+#define SRC_TINT_SEM_EXTERNAL_TEXTURE_H_
+
+#include <unordered_map>
+
+#include "src/tint/sem/binding_point.h"
+
+namespace tint::sem::external_texture {
+
+/// This struct identifies the binding groups and locations for new bindings to
+/// use when transforming a texture_external instance.
+struct BindingPoints {
+    /// The desired binding location of the texture_2d representing plane #1 when
+    /// a texture_external binding is expanded.
+    BindingPoint plane_1;
+    /// The desired binding location of the ExternalTextureParams uniform when a
+    /// texture_external binding is expanded.
+    BindingPoint params;
+
+    /// Reflect the fields of this class so that it can be used by tint::ForeachField()
+    TINT_REFLECT(plane_1, params);
+};
+
+/// BindingsMap is a map where the key is the binding location of a
+/// texture_external and the value is a struct containing the desired
+/// locations for new bindings expanded from the texture_external instance.
+using BindingsMap = std::unordered_map<BindingPoint, BindingPoints>;
+
+}  // namespace tint::sem::external_texture
+
+#endif  // SRC_TINT_SEM_EXTERNAL_TEXTURE_H_
diff --git a/src/tint/sem/info.cc b/src/tint/sem/info.cc
index e124c1c..52a04b5 100644
--- a/src/tint/sem/info.cc
+++ b/src/tint/sem/info.cc
@@ -18,6 +18,7 @@
 #include "src/tint/sem/module.h"
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 
 namespace tint::sem {
 
diff --git a/src/tint/sem/value_expression.cc b/src/tint/sem/value_expression.cc
index 9fe4615..9aacfa3 100644
--- a/src/tint/sem/value_expression.cc
+++ b/src/tint/sem/value_expression.cc
@@ -18,6 +18,7 @@
 
 #include "src/tint/sem/load.h"
 #include "src/tint/sem/materialize.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::sem::ValueExpression);
 
diff --git a/src/tint/sem/value_expression_test.cc b/src/tint/sem/value_expression_test.cc
index 1758894..0a2c9ef 100644
--- a/src/tint/sem/value_expression_test.cc
+++ b/src/tint/sem/value_expression_test.cc
@@ -29,9 +29,9 @@
     ~MockConstant() override {}
     const type::Type* Type() const override { return type; }
     const constant::Value* Index(size_t) const override { return {}; }
+    size_t NumElements() const override { return 0; }
     bool AllZero() const override { return {}; }
     bool AnyZero() const override { return {}; }
-    bool AllEqual() const override { return {}; }
     size_t Hash() const override { return 0; }
     MockConstant* Clone(constant::CloneContext&) const override { return nullptr; }
 
diff --git a/src/tint/switch.h b/src/tint/switch.h
new file mode 100644
index 0000000..41bb99a
--- /dev/null
+++ b/src/tint/switch.h
@@ -0,0 +1,262 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_SWITCH_H_
+#define SRC_TINT_SWITCH_H_
+
+#include <tuple>
+#include <utility>
+
+#include "src/tint/castable.h"
+#include "src/tint/utils/bitcast.h"
+#include "src/tint/utils/defer.h"
+
+namespace tint {
+
+/// Default can be used as the default case for a Switch(), when all previous cases failed to match.
+///
+/// Example:
+/// ```
+/// Switch(object,
+///     [&](TypeA*) { /* ... */ },
+///     [&](TypeB*) { /* ... */ },
+///     [&](Default) { /* If not TypeA or TypeB */ });
+/// ```
+struct Default {};
+
+}  // namespace tint
+
+namespace tint::detail {
+
+/// Evaluates to the Switch case type being matched by the switch case function `FN`.
+/// @note does not handle the Default case
+/// @see Switch().
+template <typename FN>
+using SwitchCaseType = std::remove_pointer_t<traits::ParameterType<std::remove_reference_t<FN>, 0>>;
+
+/// Evaluates to true if the function `FN` has the signature of a Default case in a Switch().
+/// @see Switch().
+template <typename FN>
+inline constexpr bool IsDefaultCase =
+    std::is_same_v<traits::ParameterType<std::remove_reference_t<FN>, 0>, Default>;
+
+/// Searches the list of Switch cases for a Default case, returning the index of the Default case.
+/// If the a Default case is not found in the tuple, then -1 is returned.
+template <typename TUPLE, std::size_t START_IDX = 0>
+constexpr int IndexOfDefaultCase() {
+    if constexpr (START_IDX < std::tuple_size_v<TUPLE>) {
+        return IsDefaultCase<std::tuple_element_t<START_IDX, TUPLE>>
+                   ? static_cast<int>(START_IDX)
+                   : IndexOfDefaultCase<TUPLE, START_IDX + 1>();
+    } else {
+        return -1;
+    }
+}
+
+/// Resolves to T if T is not nullptr_t, otherwise resolves to Ignore.
+template <typename T>
+using NullptrToIgnore = std::conditional_t<std::is_same_v<T, std::nullptr_t>, Ignore, T>;
+
+/// Resolves to `const TYPE` if any of `CASE_RETURN_TYPES` are const or pointer-to-const, otherwise
+/// resolves to TYPE.
+template <typename TYPE, typename... CASE_RETURN_TYPES>
+using PropagateReturnConst = std::conditional_t<
+    // Are any of the pointer-stripped types const?
+    (std::is_const_v<std::remove_pointer_t<CASE_RETURN_TYPES>> || ...),
+    const TYPE,  // Yes: Apply const to TYPE
+    TYPE>;       // No:  Passthrough
+
+/// SwitchReturnTypeImpl is the implementation of SwitchReturnType
+template <bool IS_CASTABLE, typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
+struct SwitchReturnTypeImpl;
+
+/// SwitchReturnTypeImpl specialization for non-castable case types and an explicitly specified
+/// return type.
+template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
+struct SwitchReturnTypeImpl</*IS_CASTABLE*/ false, REQUESTED_TYPE, CASE_RETURN_TYPES...> {
+    /// Resolves to `REQUESTED_TYPE`
+    using type = REQUESTED_TYPE;
+};
+
+/// SwitchReturnTypeImpl specialization for non-castable case types and an inferred return type.
+template <typename... CASE_RETURN_TYPES>
+struct SwitchReturnTypeImpl</*IS_CASTABLE*/ false, Infer, CASE_RETURN_TYPES...> {
+    /// Resolves to the common type for all the cases return types.
+    using type = std::common_type_t<CASE_RETURN_TYPES...>;
+};
+
+/// SwitchReturnTypeImpl specialization for castable case types and an explicitly specified return
+/// type.
+template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
+struct SwitchReturnTypeImpl</*IS_CASTABLE*/ true, REQUESTED_TYPE, CASE_RETURN_TYPES...> {
+  public:
+    /// Resolves to `const REQUESTED_TYPE*` or `REQUESTED_TYPE*`
+    using type = PropagateReturnConst<std::remove_pointer_t<REQUESTED_TYPE>, CASE_RETURN_TYPES...>*;
+};
+
+/// SwitchReturnTypeImpl specialization for castable case types and an inferred return type.
+template <typename... CASE_RETURN_TYPES>
+struct SwitchReturnTypeImpl</*IS_CASTABLE*/ true, Infer, CASE_RETURN_TYPES...> {
+  private:
+    using InferredType =
+        CastableCommonBase<detail::NullptrToIgnore<std::remove_pointer_t<CASE_RETURN_TYPES>>...>;
+
+  public:
+    /// `const T*` or `T*`, where T is the common base type for all the castable case types.
+    using type = PropagateReturnConst<InferredType, CASE_RETURN_TYPES...>*;
+};
+
+/// Resolves to the return type for a Switch() with the requested return type `REQUESTED_TYPE` and
+/// case statement return types. If `REQUESTED_TYPE` is Infer then the return type will be inferred
+/// from the case return types.
+template <typename REQUESTED_TYPE, typename... CASE_RETURN_TYPES>
+using SwitchReturnType = typename SwitchReturnTypeImpl<
+    IsCastable<NullptrToIgnore<std::remove_pointer_t<CASE_RETURN_TYPES>>...>,
+    REQUESTED_TYPE,
+    CASE_RETURN_TYPES...>::type;
+
+}  // namespace tint::detail
+
+namespace tint {
+
+/// Switch is used to dispatch one of the provided callback case handler functions based on the type
+/// of `object` and the parameter type of the case handlers. Switch will sequentially check the type
+/// of `object` against each of the switch case handler functions, and will invoke the first case
+/// handler function which has a parameter type that matches the object type. When a case handler is
+/// matched, it will be called with the single argument of `object` cast to the case handler's
+/// parameter type. Switch will invoke at most one case handler. Each of the case functions must
+/// have the signature `R(T*)` or `R(const T*)`, where `T` is the type matched by that case and `R`
+/// is the return type, consistent across all case handlers.
+///
+/// An optional default case function with the signature `R(Default)` can be used as the last case.
+/// This default case will be called if all previous cases failed to match.
+///
+/// If `object` is nullptr and a default case is provided, then the default case will be called. If
+/// `object` is nullptr and no default case is provided, then no cases will be called.
+///
+/// Example:
+/// ```
+/// Switch(object,
+///     [&](TypeA*) { /* ... */ },
+///     [&](TypeB*) { /* ... */ });
+///
+/// Switch(object,
+///     [&](TypeA*) { /* ... */ },
+///     [&](TypeB*) { /* ... */ },
+///     [&](Default) { /* Called if object is not TypeA or TypeB */ });
+/// ```
+///
+/// @param object the object who's type is used to
+/// @param cases the switch cases
+/// @return the value returned by the called case. If no cases matched, then the zero value for the
+/// consistent case type.
+template <typename RETURN_TYPE = detail::Infer, typename T = CastableBase, typename... CASES>
+inline auto Switch(T* object, CASES&&... cases) {
+    using ReturnType = detail::SwitchReturnType<RETURN_TYPE, traits::ReturnType<CASES>...>;
+    static constexpr int kDefaultIndex = detail::IndexOfDefaultCase<std::tuple<CASES...>>();
+    static constexpr bool kHasDefaultCase = kDefaultIndex >= 0;
+    static constexpr bool kHasReturnType = !std::is_same_v<ReturnType, void>;
+
+    // Static assertions
+    static constexpr bool kDefaultIsOK =
+        kDefaultIndex == -1 || kDefaultIndex == static_cast<int>(sizeof...(CASES) - 1);
+    static constexpr bool kReturnIsOK =
+        kHasDefaultCase || !kHasReturnType || std::is_constructible_v<ReturnType>;
+    static_assert(kDefaultIsOK, "Default case must be last in Switch()");
+    static_assert(kReturnIsOK,
+                  "Switch() requires either a Default case or a return type that is either void or "
+                  "default-constructable");
+
+    if (!object) {  // Object is nullptr, so no cases can match
+        if constexpr (kHasDefaultCase) {
+            // Evaluate default case.
+            auto&& default_case =
+                std::get<kDefaultIndex>(std::forward_as_tuple(std::forward<CASES>(cases)...));
+            return static_cast<ReturnType>(default_case(Default{}));
+        } else {
+            // No default case, no case can match.
+            if constexpr (kHasReturnType) {
+                return ReturnType{};
+            } else {
+                return;
+            }
+        }
+    }
+
+    // Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
+    using ReturnTypeOrU8 = std::conditional_t<kHasReturnType, ReturnType, uint8_t>;
+    struct alignas(alignof(ReturnTypeOrU8)) ReturnStorage {
+        uint8_t data[sizeof(ReturnTypeOrU8)];
+    };
+    ReturnStorage storage;
+    auto* result = utils::Bitcast<ReturnTypeOrU8*>(&storage);
+
+    const TypeInfo& type_info = object->TypeInfo();
+
+    // Examines the parameter type of the case function.
+    // If the parameter is a pointer type that `object` is of, or derives from, then that case
+    // function is called with `object` cast to that type, and `try_case` returns true.
+    // If the parameter is of type `Default`, then that case function is called and `try_case`
+    // returns true.
+    // Otherwise `try_case` returns false.
+    // If the case function is called and it returns a value, then this is copy constructed to the
+    // `result` pointer.
+    auto try_case = [&](auto&& case_fn) {
+        using CaseFunc = std::decay_t<decltype(case_fn)>;
+        using CaseType = detail::SwitchCaseType<CaseFunc>;
+        bool success = false;
+        if constexpr (std::is_same_v<CaseType, Default>) {
+            if constexpr (kHasReturnType) {
+                new (result) ReturnType(static_cast<ReturnType>(case_fn(Default{})));
+            } else {
+                case_fn(Default{});
+            }
+            success = true;
+        } else {
+            if (type_info.Is<CaseType>()) {
+                auto* v = static_cast<CaseType*>(object);
+                if constexpr (kHasReturnType) {
+                    new (result) ReturnType(static_cast<ReturnType>(case_fn(v)));
+                } else {
+                    case_fn(v);
+                }
+                success = true;
+            }
+        }
+        return success;
+    };
+
+    // Use a logical-or fold expression to try each of the cases in turn, until one matches the
+    // object type or a Default is reached. `handled` is true if a case function was called.
+    bool handled = ((try_case(std::forward<CASES>(cases)) || ...));
+
+    if constexpr (kHasReturnType) {
+        if constexpr (kHasDefaultCase) {
+            // Default case means there must be a returned value.
+            // No need to check handled, no requirement for a zero-initializer of ReturnType.
+            TINT_DEFER(result->~ReturnType());
+            return *result;
+        } else {
+            if (handled) {
+                TINT_DEFER(result->~ReturnType());
+                return *result;
+            }
+            return ReturnType{};
+        }
+    }
+}
+
+}  // namespace tint
+
+#endif  // SRC_TINT_SWITCH_H_
diff --git a/src/tint/castable_bench.cc b/src/tint/switch_bench.cc
similarity index 99%
rename from src/tint/castable_bench.cc
rename to src/tint/switch_bench.cc
index c9d0c43..ea6098b 100644
--- a/src/tint/castable_bench.cc
+++ b/src/tint/switch_bench.cc
@@ -16,7 +16,7 @@
 
 #include "benchmark/benchmark.h"
 
-#include "src/tint/castable.h"
+#include "src/tint/switch.h"
 
 namespace tint {
 namespace {
diff --git a/src/tint/switch_test.cc b/src/tint/switch_test.cc
new file mode 100644
index 0000000..d93f830
--- /dev/null
+++ b/src/tint/switch_test.cc
@@ -0,0 +1,552 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/switch.h"
+
+#include <memory>
+#include <string>
+
+#include "gtest/gtest.h"
+
+namespace tint {
+namespace {
+
+struct Animal : public tint::Castable<Animal> {};
+struct Amphibian : public tint::Castable<Amphibian, Animal> {};
+struct Mammal : public tint::Castable<Mammal, Animal> {};
+struct Reptile : public tint::Castable<Reptile, Animal> {};
+struct Frog : public tint::Castable<Frog, Amphibian> {};
+struct Bear : public tint::Castable<Bear, Mammal> {};
+struct Lizard : public tint::Castable<Lizard, Reptile> {};
+struct Gecko : public tint::Castable<Gecko, Lizard> {};
+struct Iguana : public tint::Castable<Iguana, Lizard> {};
+
+TEST(Castable, SwitchNoDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        bool frog_matched_amphibian = false;
+        Switch(
+            frog.get(),  //
+            [&](Reptile*) { FAIL() << "frog is not reptile"; },
+            [&](Mammal*) { FAIL() << "frog is not mammal"; },
+            [&](Amphibian* amphibian) {
+                EXPECT_EQ(amphibian, frog.get());
+                frog_matched_amphibian = true;
+            });
+        EXPECT_TRUE(frog_matched_amphibian);
+    }
+    {
+        bool bear_matched_mammal = false;
+        Switch(
+            bear.get(),  //
+            [&](Reptile*) { FAIL() << "bear is not reptile"; },
+            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
+            [&](Mammal* mammal) {
+                EXPECT_EQ(mammal, bear.get());
+                bear_matched_mammal = true;
+            });
+        EXPECT_TRUE(bear_matched_mammal);
+    }
+    {
+        bool gecko_matched_reptile = false;
+        Switch(
+            gecko.get(),  //
+            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
+            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
+            [&](Reptile* reptile) {
+                EXPECT_EQ(reptile, gecko.get());
+                gecko_matched_reptile = true;
+            });
+        EXPECT_TRUE(gecko_matched_reptile);
+    }
+}
+
+TEST(Castable, SwitchWithUnusedDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        bool frog_matched_amphibian = false;
+        Switch(
+            frog.get(),  //
+            [&](Reptile*) { FAIL() << "frog is not reptile"; },
+            [&](Mammal*) { FAIL() << "frog is not mammal"; },
+            [&](Amphibian* amphibian) {
+                EXPECT_EQ(amphibian, frog.get());
+                frog_matched_amphibian = true;
+            },
+            [&](Default) { FAIL() << "default should not have been selected"; });
+        EXPECT_TRUE(frog_matched_amphibian);
+    }
+    {
+        bool bear_matched_mammal = false;
+        Switch(
+            bear.get(),  //
+            [&](Reptile*) { FAIL() << "bear is not reptile"; },
+            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
+            [&](Mammal* mammal) {
+                EXPECT_EQ(mammal, bear.get());
+                bear_matched_mammal = true;
+            },
+            [&](Default) { FAIL() << "default should not have been selected"; });
+        EXPECT_TRUE(bear_matched_mammal);
+    }
+    {
+        bool gecko_matched_reptile = false;
+        Switch(
+            gecko.get(),  //
+            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
+            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
+            [&](Reptile* reptile) {
+                EXPECT_EQ(reptile, gecko.get());
+                gecko_matched_reptile = true;
+            },
+            [&](Default) { FAIL() << "default should not have been selected"; });
+        EXPECT_TRUE(gecko_matched_reptile);
+    }
+}
+
+TEST(Castable, SwitchDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        bool frog_matched_default = false;
+        Switch(
+            frog.get(),  //
+            [&](Reptile*) { FAIL() << "frog is not reptile"; },
+            [&](Mammal*) { FAIL() << "frog is not mammal"; },
+            [&](Default) { frog_matched_default = true; });
+        EXPECT_TRUE(frog_matched_default);
+    }
+    {
+        bool bear_matched_default = false;
+        Switch(
+            bear.get(),  //
+            [&](Reptile*) { FAIL() << "bear is not reptile"; },
+            [&](Amphibian*) { FAIL() << "bear is not amphibian"; },
+            [&](Default) { bear_matched_default = true; });
+        EXPECT_TRUE(bear_matched_default);
+    }
+    {
+        bool gecko_matched_default = false;
+        Switch(
+            gecko.get(),  //
+            [&](Mammal*) { FAIL() << "gecko is not mammal"; },
+            [&](Amphibian*) { FAIL() << "gecko is not amphibian"; },
+            [&](Default) { gecko_matched_default = true; });
+        EXPECT_TRUE(gecko_matched_default);
+    }
+}
+
+TEST(Castable, SwitchMatchFirst) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    {
+        bool frog_matched_animal = false;
+        Switch(
+            frog.get(),
+            [&](Animal* animal) {
+                EXPECT_EQ(animal, frog.get());
+                frog_matched_animal = true;
+            },
+            [&](Amphibian*) { FAIL() << "animal should have been matched first"; });
+        EXPECT_TRUE(frog_matched_animal);
+    }
+    {
+        bool frog_matched_amphibian = false;
+        Switch(
+            frog.get(),
+            [&](Amphibian* amphibain) {
+                EXPECT_EQ(amphibain, frog.get());
+                frog_matched_amphibian = true;
+            },
+            [&](Animal*) { FAIL() << "amphibian should have been matched first"; });
+        EXPECT_TRUE(frog_matched_amphibian);
+    }
+}
+
+TEST(Castable, SwitchReturnValueWithDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        const char* result = Switch(
+            frog.get(),                              //
+            [](Mammal*) { return "mammal"; },        //
+            [](Amphibian*) { return "amphibian"; },  //
+            [](Default) { return "unknown"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(std::string(result), "amphibian");
+    }
+    {
+        const char* result = Switch(
+            bear.get(),                              //
+            [](Mammal*) { return "mammal"; },        //
+            [](Amphibian*) { return "amphibian"; },  //
+            [](Default) { return "unknown"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(std::string(result), "mammal");
+    }
+    {
+        const char* result = Switch(
+            gecko.get(),                             //
+            [](Mammal*) { return "mammal"; },        //
+            [](Amphibian*) { return "amphibian"; },  //
+            [](Default) { return "unknown"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(std::string(result), "unknown");
+    }
+}
+
+TEST(Castable, SwitchReturnValueWithoutDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        const char* result = Switch(
+            frog.get(),                        //
+            [](Mammal*) { return "mammal"; },  //
+            [](Amphibian*) { return "amphibian"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(std::string(result), "amphibian");
+    }
+    {
+        const char* result = Switch(
+            bear.get(),                        //
+            [](Mammal*) { return "mammal"; },  //
+            [](Amphibian*) { return "amphibian"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(std::string(result), "mammal");
+    }
+    {
+        auto* result = Switch(
+            gecko.get(),                       //
+            [](Mammal*) { return "mammal"; },  //
+            [](Amphibian*) { return "amphibian"; });
+        static_assert(std::is_same_v<decltype(result), const char*>);
+        EXPECT_EQ(result, nullptr);
+    }
+}
+
+TEST(Castable, SwitchInferPODReturnTypeWithDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto result = Switch(
+            frog.get(),                       //
+            [](Mammal*) { return 1; },        //
+            [](Amphibian*) { return 2.0f; },  //
+            [](Default) { return 3.0; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 2.0);
+    }
+    {
+        auto result = Switch(
+            bear.get(),                       //
+            [](Mammal*) { return 1.0; },      //
+            [](Amphibian*) { return 2.0f; },  //
+            [](Default) { return 3; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 1.0);
+    }
+    {
+        auto result = Switch(
+            gecko.get(),                   //
+            [](Mammal*) { return 1.0f; },  //
+            [](Amphibian*) { return 2; },  //
+            [](Default) { return 3.0; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 3.0);
+    }
+}
+
+TEST(Castable, SwitchInferPODReturnTypeWithoutDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto result = Switch(
+            frog.get(),                 //
+            [](Mammal*) { return 1; },  //
+            [](Amphibian*) { return 2.0f; });
+        static_assert(std::is_same_v<decltype(result), float>);
+        EXPECT_EQ(result, 2.0f);
+    }
+    {
+        auto result = Switch(
+            bear.get(),                    //
+            [](Mammal*) { return 1.0f; },  //
+            [](Amphibian*) { return 2; });
+        static_assert(std::is_same_v<decltype(result), float>);
+        EXPECT_EQ(result, 1.0f);
+    }
+    {
+        auto result = Switch(
+            gecko.get(),                  //
+            [](Mammal*) { return 1.0; },  //
+            [](Amphibian*) { return 2.0f; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 0.0);
+    }
+}
+
+TEST(Castable, SwitchInferCastableReturnTypeWithDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto* result = Switch(
+            frog.get(),                          //
+            [](Mammal* p) { return p; },         //
+            [](Amphibian*) { return nullptr; },  //
+            [](Default) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), Mammal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+    {
+        auto* result = Switch(
+            bear.get(),                   //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian* p) { return const_cast<const Amphibian*>(p); },
+            [](Default) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), const Animal*>);
+        EXPECT_EQ(result, bear.get());
+    }
+    {
+        auto* result = Switch(
+            gecko.get(),                     //
+            [](Mammal* p) { return p; },     //
+            [](Amphibian* p) { return p; },  //
+            [](Default) -> CastableBase* { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), CastableBase*>);
+        EXPECT_EQ(result, nullptr);
+    }
+}
+
+TEST(Castable, SwitchInferCastableReturnTypeWithoutDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto* result = Switch(
+            frog.get(),                   //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian*) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), Mammal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+    {
+        auto* result = Switch(
+            bear.get(),                                                     //
+            [](Mammal* p) { return p; },                                    //
+            [](Amphibian* p) { return const_cast<const Amphibian*>(p); });  //
+        static_assert(std::is_same_v<decltype(result), const Animal*>);
+        EXPECT_EQ(result, bear.get());
+    }
+    {
+        auto* result = Switch(
+            gecko.get(),                  //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian* p) { return p; });
+        static_assert(std::is_same_v<decltype(result), Animal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+}
+
+TEST(Castable, SwitchExplicitPODReturnTypeWithDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto result = Switch<double>(
+            frog.get(),                       //
+            [](Mammal*) { return 1; },        //
+            [](Amphibian*) { return 2.0f; },  //
+            [](Default) { return 3.0; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 2.0f);
+    }
+    {
+        auto result = Switch<double>(
+            bear.get(),                    //
+            [](Mammal*) { return 1; },     //
+            [](Amphibian*) { return 2; },  //
+            [](Default) { return 3; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 1.0f);
+    }
+    {
+        auto result = Switch<double>(
+            gecko.get(),                      //
+            [](Mammal*) { return 1.0f; },     //
+            [](Amphibian*) { return 2.0f; },  //
+            [](Default) { return 3.0f; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 3.0f);
+    }
+}
+
+TEST(Castable, SwitchExplicitPODReturnTypeWithoutDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto result = Switch<double>(
+            frog.get(),                 //
+            [](Mammal*) { return 1; },  //
+            [](Amphibian*) { return 2.0f; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 2.0f);
+    }
+    {
+        auto result = Switch<double>(
+            bear.get(),                    //
+            [](Mammal*) { return 1.0f; },  //
+            [](Amphibian*) { return 2; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 1.0f);
+    }
+    {
+        auto result = Switch<double>(
+            gecko.get(),                  //
+            [](Mammal*) { return 1.0; },  //
+            [](Amphibian*) { return 2.0f; });
+        static_assert(std::is_same_v<decltype(result), double>);
+        EXPECT_EQ(result, 0.0);
+    }
+}
+
+TEST(Castable, SwitchExplicitCastableReturnTypeWithDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto* result = Switch<Animal>(
+            frog.get(),                          //
+            [](Mammal* p) { return p; },         //
+            [](Amphibian*) { return nullptr; },  //
+            [](Default) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), Animal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+    {
+        auto* result = Switch<CastableBase>(
+            bear.get(),                   //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian* p) { return const_cast<const Amphibian*>(p); },
+            [](Default) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), const CastableBase*>);
+        EXPECT_EQ(result, bear.get());
+    }
+    {
+        auto* result = Switch<const Animal>(
+            gecko.get(),                     //
+            [](Mammal* p) { return p; },     //
+            [](Amphibian* p) { return p; },  //
+            [](Default) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), const Animal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+}
+
+TEST(Castable, SwitchExplicitCastableReturnTypeWithoutDefault) {
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    std::unique_ptr<Animal> bear = std::make_unique<Bear>();
+    std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
+    {
+        auto* result = Switch<Animal>(
+            frog.get(),                   //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian*) { return nullptr; });
+        static_assert(std::is_same_v<decltype(result), Animal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+    {
+        auto* result = Switch<CastableBase>(
+            bear.get(),                                                     //
+            [](Mammal* p) { return p; },                                    //
+            [](Amphibian* p) { return const_cast<const Amphibian*>(p); });  //
+        static_assert(std::is_same_v<decltype(result), const CastableBase*>);
+        EXPECT_EQ(result, bear.get());
+    }
+    {
+        auto* result = Switch<const Animal*>(
+            gecko.get(),                  //
+            [](Mammal* p) { return p; },  //
+            [](Amphibian* p) { return p; });
+        static_assert(std::is_same_v<decltype(result), const Animal*>);
+        EXPECT_EQ(result, nullptr);
+    }
+}
+
+TEST(Castable, SwitchNull) {
+    Animal* null = nullptr;
+    Switch(
+        null,  //
+        [&](Amphibian*) { FAIL() << "should not be called"; },
+        [&](Animal*) { FAIL() << "should not be called"; });
+}
+
+TEST(Castable, SwitchNullNoDefault) {
+    Animal* null = nullptr;
+    bool default_called = false;
+    Switch(
+        null,  //
+        [&](Amphibian*) { FAIL() << "should not be called"; },
+        [&](Animal*) { FAIL() << "should not be called"; },
+        [&](Default) { default_called = true; });
+    EXPECT_TRUE(default_called);
+}
+
+TEST(Castable, SwitchReturnNoDefaultInitializer) {
+    struct Object {
+        explicit Object(int v) : value(v) {}
+        int value;
+    };
+
+    std::unique_ptr<Animal> frog = std::make_unique<Frog>();
+    {
+        auto result = Switch(
+            frog.get(),                            //
+            [](Mammal*) { return Object(1); },     //
+            [](Amphibian*) { return Object(2); },  //
+            [](Default) { return Object(3); });
+        static_assert(std::is_same_v<decltype(result), Object>);
+        EXPECT_EQ(result.value, 2);
+    }
+    {
+        auto result = Switch(
+            frog.get(),                         //
+            [](Mammal*) { return Object(1); },  //
+            [](Default) { return Object(3); });
+        static_assert(std::is_same_v<decltype(result), Object>);
+        EXPECT_EQ(result.value, 3);
+    }
+}
+
+}  // namespace
+
+TINT_INSTANTIATE_TYPEINFO(Animal);
+TINT_INSTANTIATE_TYPEINFO(Amphibian);
+TINT_INSTANTIATE_TYPEINFO(Mammal);
+TINT_INSTANTIATE_TYPEINFO(Reptile);
+TINT_INSTANTIATE_TYPEINFO(Frog);
+TINT_INSTANTIATE_TYPEINFO(Bear);
+TINT_INSTANTIATE_TYPEINFO(Lizard);
+TINT_INSTANTIATE_TYPEINFO(Gecko);
+
+}  // namespace tint
diff --git a/src/tint/transform/array_length_from_uniform.cc b/src/tint/transform/array_length_from_uniform.cc
index 78535f1..a396965 100644
--- a/src/tint/transform/array_length_from_uniform.cc
+++ b/src/tint/transform/array_length_from_uniform.cc
@@ -37,7 +37,7 @@
     for (auto* fn : program->AST().Functions()) {
         if (auto* sem_fn = program->Sem().Get(fn)) {
             for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
-                if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+                if (builtin->Type() == builtin::Function::kArrayLength) {
                     return true;
                 }
             }
@@ -199,7 +199,7 @@
 
             auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
             auto* builtin = call->Target()->As<sem::Builtin>();
-            if (!builtin || builtin->Type() != sem::BuiltinType::kArrayLength) {
+            if (!builtin || builtin->Type() != builtin::Function::kArrayLength) {
                 continue;
             }
 
diff --git a/src/tint/transform/builtin_polyfill.cc b/src/tint/transform/builtin_polyfill.cc
index 259eb11..cc770ab 100644
--- a/src/tint/transform/builtin_polyfill.cc
+++ b/src/tint/transform/builtin_polyfill.cc
@@ -23,6 +23,8 @@
 #include "src/tint/sem/builtin.h"
 #include "src/tint/sem/call.h"
 #include "src/tint/sem/type_expression.h"
+#include "src/tint/sem/value_conversion.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/storage_texture.h"
 #include "src/tint/type/texture_dimension.h"
 #include "src/tint/utils/map.h"
@@ -40,17 +42,123 @@
 /// PIMPL state for the transform
 struct BuiltinPolyfill::State {
     /// Constructor
-    /// @param c the CloneContext
-    /// @param p the builtins to polyfill
-    State(CloneContext& c, Builtins p) : ctx(c), polyfill(p) {
+    /// @param program the source program
+    /// @param config the transform config
+    State(const Program* program, const Config& config) : src(program), cfg(config) {
         has_full_ptr_params = false;
-        for (auto* enable : c.src->AST().Enables()) {
-            if (enable->extension == builtin::Extension::kChromiumExperimentalFullPtrParameters) {
+        for (auto* enable : src->AST().Enables()) {
+            if (enable->HasExtension(builtin::Extension::kChromiumExperimentalFullPtrParameters)) {
                 has_full_ptr_params = true;
+                break;
             }
         }
     }
 
+    /// Runs the transform
+    /// @returns the new program or SkipTransform if the transform is not required
+    Transform::ApplyResult Run() {
+        for (auto* node : src->ASTNodes().Objects()) {
+            Switch(
+                node,  //
+                [&](const ast::CallExpression* expr) { Call(expr); },
+                [&](const ast::BinaryExpression* bin_op) {
+                    if (auto* s = src->Sem().Get(bin_op);
+                        !s || s->Stage() == sem::EvaluationStage::kConstant ||
+                        s->Stage() == sem::EvaluationStage::kNotEvaluated) {
+                        return;  // Don't polyfill @const expressions
+                    }
+                    switch (bin_op->op) {
+                        case ast::BinaryOp::kShiftLeft:
+                        case ast::BinaryOp::kShiftRight: {
+                            if (cfg.builtins.bitshift_modulo) {
+                                ctx.Replace(bin_op,
+                                            [this, bin_op] { return BitshiftModulo(bin_op); });
+                                made_changes = true;
+                            }
+                            break;
+                        }
+                        case ast::BinaryOp::kDivide: {
+                            if (cfg.builtins.int_div_mod) {
+                                auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
+                                if (lhs_ty->is_integer_scalar_or_vector()) {
+                                    ctx.Replace(bin_op,
+                                                [this, bin_op] { return IntDivMod(bin_op); });
+                                    made_changes = true;
+                                }
+                            }
+                            break;
+                        }
+                        case ast::BinaryOp::kModulo: {
+                            if (cfg.builtins.int_div_mod) {
+                                auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
+                                if (lhs_ty->is_integer_scalar_or_vector()) {
+                                    ctx.Replace(bin_op,
+                                                [this, bin_op] { return IntDivMod(bin_op); });
+                                    made_changes = true;
+                                }
+                            }
+                            if (cfg.builtins.precise_float_mod) {
+                                auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
+                                if (lhs_ty->is_float_scalar_or_vector()) {
+                                    ctx.Replace(bin_op,
+                                                [this, bin_op] { return PreciseFloatMod(bin_op); });
+                                    made_changes = true;
+                                }
+                            }
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                },
+                [&](const ast::Expression* expr) {
+                    if (cfg.builtins.bgra8unorm) {
+                        if (auto* ty_expr = src->Sem().Get<sem::TypeExpression>(expr)) {
+                            if (auto* tex = ty_expr->Type()->As<type::StorageTexture>()) {
+                                if (tex->texel_format() == builtin::TexelFormat::kBgra8Unorm) {
+                                    ctx.Replace(expr, [this, tex] {
+                                        return ctx.dst->Expr(ctx.dst->ty.storage_texture(
+                                            tex->dim(), builtin::TexelFormat::kRgba8Unorm,
+                                            tex->access()));
+                                    });
+                                    made_changes = true;
+                                }
+                            }
+                        }
+                    }
+                });
+        }
+
+        if (!made_changes) {
+            return SkipTransform;
+        }
+
+        ctx.Clone();
+        return Program(std::move(b));
+    }
+
+  private:
+    /// The source program
+    Program const* const src;
+    /// The transform config
+    const Config& cfg;
+    /// The destination program builder
+    ProgramBuilder b;
+    /// The clone context
+    CloneContext ctx{&b, src};
+    /// The source clone context
+    const sem::Info& sem = src->Sem();
+    /// Polyfill functions for binary operators.
+    utils::Hashmap<BinaryOpSignature, Symbol, 8> binary_op_polyfills;
+    /// Polyfill builtins.
+    utils::Hashmap<const sem::Builtin*, Symbol, 8> builtin_polyfills;
+    /// Polyfill f32 conversion to i32 or u32 (or vectors of)
+    utils::Hashmap<const type::Type*, Symbol, 2> f32_conv_polyfills;
+    // Tracks whether the chromium_experimental_full_ptr_parameters extension has been enabled.
+    bool has_full_ptr_params = false;
+    /// True if the transform has made changes (i.e. the program needs cloning)
+    bool made_changes = false;
+
     ////////////////////////////////////////////////////////////////////////////
     // Function polyfills
     ////////////////////////////////////////////////////////////////////////////
@@ -71,7 +179,7 @@
         };
 
         utils::Vector<const ast::Statement*, 4> body;
-        switch (polyfill.acosh) {
+        switch (cfg.builtins.acosh) {
             case Level::kFull:
                 // return log(x + sqrt(x*x - 1));
                 body.Push(b.Return(
@@ -85,7 +193,7 @@
             }
             default:
                 TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(polyfill.acosh);
+                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
                 return {};
         }
 
@@ -125,7 +233,7 @@
         };
 
         utils::Vector<const ast::Statement*, 1> body;
-        switch (polyfill.atanh) {
+        switch (cfg.builtins.atanh) {
             case Level::kFull:
                 // return log((1+x) / (1-x)) * 0.5
                 body.Push(
@@ -138,7 +246,7 @@
                 break;
             default:
                 TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(polyfill.acosh);
+                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
                 return {};
         }
 
@@ -306,7 +414,7 @@
             b.Decl(b.Let("e", b.Call("min", u32(W), b.Add("s", "count")))),
         };
 
-        switch (polyfill.extract_bits) {
+        switch (cfg.builtins.extract_bits) {
             case Level::kFull:
                 body.Push(b.Decl(b.Let("shl", b.Sub(u32(W), "e"))));
                 body.Push(b.Decl(b.Let("shr", b.Add("shl", "s"))));
@@ -328,7 +436,7 @@
                 break;
             default:
                 TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(polyfill.extract_bits);
+                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.extract_bits);
                 return {};
         }
 
@@ -532,7 +640,7 @@
 
         utils::Vector<const ast::Statement*, 8> body;
 
-        switch (polyfill.insert_bits) {
+        switch (cfg.builtins.insert_bits) {
             case Level::kFull:
                 // let e = offset + count;
                 body.Push(b.Decl(b.Let("e", b.Add("offset", "count"))));
@@ -566,7 +674,7 @@
                 break;
             default:
                 TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(polyfill.insert_bits);
+                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.insert_bits);
                 return {};
         }
 
@@ -718,6 +826,52 @@
         return name;
     }
 
+    /// Builds the polyfill function to value convert a scalar or vector of f32 to an i32 or u32 (or
+    /// vector of).
+    /// @param source the type of the value being converted
+    /// @param target the target conversion type
+    /// @return the polyfill function name
+    Symbol ConvF32ToIU32(const type::Type* source, const type::Type* target) {
+        struct Limits {
+            AFloat low_condition;
+            AInt low_limit;
+            AFloat high_condition;
+            AInt high_limit;
+        };
+        const bool is_signed = target->is_signed_integer_scalar_or_vector();
+        const Limits limits = is_signed ? Limits{
+                                              /* low_condition   */ -AFloat(0x80000000),
+                                              /* low_limit  */ -AInt(0x80000000),
+                                              /* high_condition  */ AFloat(0x7fffff80),
+                                              /* high_limit */ AInt(0x7fffffff),
+                                          }
+                                        : Limits{
+                                              /* low_condition   */ AFloat(0),
+                                              /* low_limit  */ AInt(0),
+                                              /* high_condition  */ AFloat(0xffffff00),
+                                              /* high_limit */ AInt(0xffffffff),
+                                          };
+
+        const uint32_t width = WidthOf(target);
+
+        // select(target(v), low_limit, v < low_condition)
+        auto* select_low = b.Call(builtin::Function::kSelect,               //
+                                  b.Call(T(target), "v"),                   //
+                                  ScalarOrVector(width, limits.low_limit),  //
+                                  b.LessThan("v", ScalarOrVector(width, limits.low_condition)));
+
+        // select(high_limit, select_low, v < high_condition)
+        auto* select_high = b.Call(builtin::Function::kSelect,                //
+                                   ScalarOrVector(width, limits.high_limit),  //
+                                   select_low,                                //
+                                   b.LessThan("v", ScalarOrVector(width, limits.high_condition)));
+
+        auto name = b.Symbols().New(is_signed ? "tint_ftoi" : "tint_ftou");
+        b.Func(name, utils::Vector{b.Param("v", T(source))}, T(target),
+               utils::Vector{b.Return(select_high)});
+        return name;
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Inline polyfills
     ////////////////////////////////////////////////////////////////////////////
@@ -727,8 +881,8 @@
     /// @param bin_op the original BinaryExpression
     /// @return the polyfill value for bitshift operation
     const ast::Expression* BitshiftModulo(const ast::BinaryExpression* bin_op) {
-        auto* lhs_ty = ctx.src->TypeOf(bin_op->lhs)->UnwrapRef();
-        auto* rhs_ty = ctx.src->TypeOf(bin_op->rhs)->UnwrapRef();
+        auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
+        auto* rhs_ty = src->TypeOf(bin_op->rhs)->UnwrapRef();
         auto* lhs_el_ty = type::Type::DeepestElementOf(lhs_ty);
         const ast::Expression* mask = b.Expr(AInt(lhs_el_ty->Size() * 8 - 1));
         if (rhs_ty->Is<type::Vector>()) {
@@ -744,8 +898,8 @@
     /// @param bin_op the original BinaryExpression
     /// @return the polyfill divide or modulo
     const ast::Expression* IntDivMod(const ast::BinaryExpression* bin_op) {
-        auto* lhs_ty = ctx.src->TypeOf(bin_op->lhs)->UnwrapRef();
-        auto* rhs_ty = ctx.src->TypeOf(bin_op->rhs)->UnwrapRef();
+        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, [&] {
             const bool is_div = bin_op->op == ast::BinaryOp::kDivide;
@@ -839,8 +993,8 @@
     /// @param bin_op the original BinaryExpression
     /// @return the polyfill divide or modulo
     const ast::Expression* PreciseFloatMod(const ast::BinaryExpression* bin_op) {
-        auto* lhs_ty = ctx.src->TypeOf(bin_op->lhs)->UnwrapRef();
-        auto* rhs_ty = ctx.src->TypeOf(bin_op->rhs)->UnwrapRef();
+        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, [&] {
             uint32_t lhs_width = 1;
@@ -887,24 +1041,8 @@
         return b.Call(fn, lhs, rhs);
     }
 
-  private:
-    /// The clone context
-    CloneContext& ctx;
-    /// The builtins to polyfill
-    Builtins polyfill;
-    /// The destination program builder
-    ProgramBuilder& b = *ctx.dst;
-    /// The source clone context
-    const sem::Info& sem = ctx.src->Sem();
-
-    // Polyfill functions for binary operators.
-    utils::Hashmap<BinaryOpSignature, Symbol, 8> binary_op_polyfills;
-
-    // Tracks whether the chromium_experimental_full_ptr_parameters extension has been enabled.
-    bool has_full_ptr_params;
-
     /// @returns the AST type for the given sem type
-    ast::Type T(const type::Type* ty) const { return CreateASTTypeFor(ctx, ty); }
+    ast::Type T(const type::Type* ty) { return CreateASTTypeFor(ctx, ty); }
 
     /// @returns 1 if `ty` is not a vector, otherwise the vector width
     uint32_t WidthOf(const type::Type* ty) const {
@@ -917,7 +1055,7 @@
     /// @returns a scalar or vector with the given width, with each element with
     /// the given value.
     template <typename T>
-    const ast::Expression* ScalarOrVector(uint32_t width, T value) const {
+    const ast::Expression* ScalarOrVector(uint32_t width, T value) {
         if (width == 1) {
             return b.Expr(value);
         }
@@ -931,6 +1069,204 @@
         }
         return b.Call(b.ty.vec<To>(width), e);
     }
+
+    /// Examines the call expression @p expr, applying any necessary polyfill transforms
+    void Call(const ast::CallExpression* expr) {
+        auto* call = src->Sem().Get(expr)->UnwrapMaterialize()->As<sem::Call>();
+        if (!call || call->Stage() == sem::EvaluationStage::kConstant ||
+            call->Stage() == sem::EvaluationStage::kNotEvaluated) {
+            return;  // Don't polyfill @const expressions
+        }
+        Symbol fn = Switch(
+            call->Target(),  //
+            [&](const sem::Builtin* builtin) {
+                switch (builtin->Type()) {
+                    case builtin::Function::kAcosh:
+                        if (cfg.builtins.acosh != Level::kNone) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return acosh(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kAsinh:
+                        if (cfg.builtins.asinh) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return asinh(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kAtanh:
+                        if (cfg.builtins.atanh != Level::kNone) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return atanh(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kClamp:
+                        if (cfg.builtins.clamp_int) {
+                            auto& sig = builtin->Signature();
+                            if (sig.parameters[0]->Type()->is_integer_scalar_or_vector()) {
+                                return builtin_polyfills.GetOrCreate(
+                                    builtin, [&] { return clampInteger(builtin->ReturnType()); });
+                            }
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kCountLeadingZeros:
+                        if (cfg.builtins.count_leading_zeros) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return countLeadingZeros(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kCountTrailingZeros:
+                        if (cfg.builtins.count_trailing_zeros) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return countTrailingZeros(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kExtractBits:
+                        if (cfg.builtins.extract_bits != Level::kNone) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return extractBits(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kFirstLeadingBit:
+                        if (cfg.builtins.first_leading_bit) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return firstLeadingBit(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kFirstTrailingBit:
+                        if (cfg.builtins.first_trailing_bit) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return firstTrailingBit(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kInsertBits:
+                        if (cfg.builtins.insert_bits != Level::kNone) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return insertBits(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kReflect:
+                        // Only polyfill for vec2<f32>. See https://crbug.com/tint/1798 for
+                        // more details.
+                        if (cfg.builtins.reflect_vec2_f32) {
+                            auto& sig = builtin->Signature();
+                            auto* vec = sig.return_type->As<type::Vector>();
+                            if (vec && vec->Width() == 2 && vec->type()->Is<type::F32>()) {
+                                return builtin_polyfills.GetOrCreate(
+                                    builtin, [&] { return reflect(builtin->ReturnType()); });
+                            }
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kSaturate:
+                        if (cfg.builtins.saturate) {
+                            return builtin_polyfills.GetOrCreate(
+                                builtin, [&] { return saturate(builtin->ReturnType()); });
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kSign:
+                        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 Symbol{};
+
+                    case builtin::Function::kTextureSampleBaseClampToEdge:
+                        if (cfg.builtins.texture_sample_base_clamp_to_edge_2d_f32) {
+                            auto& sig = builtin->Signature();
+                            auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
+                            if (auto* stex = tex->Type()->As<type::SampledTexture>()) {
+                                if (stex->type()->Is<type::F32>()) {
+                                    return builtin_polyfills.GetOrCreate(builtin, [&] {
+                                        return textureSampleBaseClampToEdge_2d_f32();
+                                    });
+                                }
+                            }
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kTextureStore:
+                        if (cfg.builtins.bgra8unorm) {
+                            auto& sig = builtin->Signature();
+                            auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
+                            if (auto* stex = tex->Type()->As<type::StorageTexture>()) {
+                                if (stex->texel_format() == builtin::TexelFormat::kBgra8Unorm) {
+                                    size_t value_idx = static_cast<size_t>(
+                                        sig.IndexOf(sem::ParameterUsage::kValue));
+                                    ctx.Replace(expr, [this, expr, value_idx] {
+                                        utils::Vector<const ast::Expression*, 3> args;
+                                        for (auto* arg : expr->args) {
+                                            arg = ctx.Clone(arg);
+                                            if (args.Length() == value_idx) {  // value
+                                                arg = ctx.dst->MemberAccessor(arg, "bgra");
+                                            }
+                                            args.Push(arg);
+                                        }
+                                        return ctx.dst->Call(
+                                            utils::ToString(builtin::Function::kTextureStore),
+                                            std::move(args));
+                                    });
+                                    made_changes = true;
+                                }
+                            }
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kQuantizeToF16:
+                        if (cfg.builtins.quantize_to_vec_f16) {
+                            if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+                                return builtin_polyfills.GetOrCreate(
+                                    builtin, [&] { return quantizeToF16(vec); });
+                            }
+                        }
+                        return Symbol{};
+
+                    case builtin::Function::kWorkgroupUniformLoad:
+                        if (cfg.builtins.workgroup_uniform_load) {
+                            return builtin_polyfills.GetOrCreate(builtin, [&] {
+                                return workgroupUniformLoad(builtin->ReturnType());
+                            });
+                        }
+                        return Symbol{};
+
+                    default:
+                        return Symbol{};
+                }
+            },
+            [&](const sem::ValueConversion* conv) {
+                if (cfg.builtins.conv_f32_to_iu32) {
+                    auto* src_ty = conv->Source();
+                    if (tint::Is<type::F32>(type::Type::ElementOf(src_ty))) {
+                        auto* dst_ty = conv->Target();
+                        if (tint::IsAnyOf<type::I32, type::U32>(type::Type::ElementOf(dst_ty))) {
+                            return f32_conv_polyfills.GetOrCreate(dst_ty, [&] {  //
+                                return ConvF32ToIU32(src_ty, dst_ty);
+                            });
+                        }
+                    }
+                }
+                return Symbol{};
+            });
+
+        if (fn.IsValid()) {
+            ctx.Replace(call->Declaration(),
+                        [this, fn, expr] { return ctx.dst->Call(fn, ctx.Clone(expr->args)); });
+            made_changes = true;
+        }
+    }
 };
 
 BuiltinPolyfill::BuiltinPolyfill() = default;
@@ -944,261 +1280,7 @@
     if (!cfg) {
         return SkipTransform;
     }
-
-    auto& polyfill = cfg->builtins;
-
-    utils::Hashmap<const sem::Builtin*, Symbol, 8> builtin_polyfills;
-
-    ProgramBuilder b;
-    CloneContext ctx{&b, src, /* auto_clone_symbols */ true};
-    State s{ctx, polyfill};
-
-    bool made_changes = false;
-    for (auto* node : src->ASTNodes().Objects()) {
-        Switch(
-            node,
-            [&](const ast::CallExpression* expr) {
-                auto* call = src->Sem().Get(expr)->UnwrapMaterialize()->As<sem::Call>();
-                if (!call || call->Stage() == sem::EvaluationStage::kConstant ||
-                    call->Stage() == sem::EvaluationStage::kNotEvaluated) {
-                    return;  // Don't polyfill @const expressions
-                }
-                auto* builtin = call->Target()->As<sem::Builtin>();
-                if (!builtin) {
-                    return;
-                }
-                Symbol fn;
-                switch (builtin->Type()) {
-                    case sem::BuiltinType::kAcosh:
-                        if (polyfill.acosh != Level::kNone) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.acosh(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kAsinh:
-                        if (polyfill.asinh) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.asinh(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kAtanh:
-                        if (polyfill.atanh != Level::kNone) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.atanh(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kClamp:
-                        if (polyfill.clamp_int) {
-                            auto& sig = builtin->Signature();
-                            if (sig.parameters[0]->Type()->is_integer_scalar_or_vector()) {
-                                fn = builtin_polyfills.GetOrCreate(
-                                    builtin, [&] { return s.clampInteger(builtin->ReturnType()); });
-                            }
-                        }
-                        break;
-                    case sem::BuiltinType::kCountLeadingZeros:
-                        if (polyfill.count_leading_zeros) {
-                            fn = builtin_polyfills.GetOrCreate(builtin, [&] {
-                                return s.countLeadingZeros(builtin->ReturnType());
-                            });
-                        }
-                        break;
-                    case sem::BuiltinType::kCountTrailingZeros:
-                        if (polyfill.count_trailing_zeros) {
-                            fn = builtin_polyfills.GetOrCreate(builtin, [&] {
-                                return s.countTrailingZeros(builtin->ReturnType());
-                            });
-                        }
-                        break;
-                    case sem::BuiltinType::kExtractBits:
-                        if (polyfill.extract_bits != Level::kNone) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.extractBits(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kFirstLeadingBit:
-                        if (polyfill.first_leading_bit) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.firstLeadingBit(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kFirstTrailingBit:
-                        if (polyfill.first_trailing_bit) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.firstTrailingBit(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kInsertBits:
-                        if (polyfill.insert_bits != Level::kNone) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.insertBits(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kReflect:
-                        // Only polyfill for vec2<f32>. See https://crbug.com/tint/1798 for more
-                        // details.
-                        if (polyfill.reflect_vec2_f32) {
-                            auto& sig = builtin->Signature();
-                            auto* vec = sig.return_type->As<type::Vector>();
-                            if (vec && vec->Width() == 2 && vec->type()->Is<type::F32>()) {
-                                fn = builtin_polyfills.GetOrCreate(
-                                    builtin, [&] { return s.reflect(builtin->ReturnType()); });
-                            }
-                        }
-                        break;
-                    case sem::BuiltinType::kSaturate:
-                        if (polyfill.saturate) {
-                            fn = builtin_polyfills.GetOrCreate(
-                                builtin, [&] { return s.saturate(builtin->ReturnType()); });
-                        }
-                        break;
-                    case sem::BuiltinType::kSign:
-                        if (polyfill.sign_int) {
-                            auto* ty = builtin->ReturnType();
-                            if (ty->is_signed_integer_scalar_or_vector()) {
-                                fn = builtin_polyfills.GetOrCreate(builtin,
-                                                                   [&] { return s.sign_int(ty); });
-                            }
-                        }
-                        break;
-                    case sem::BuiltinType::kTextureSampleBaseClampToEdge:
-                        if (polyfill.texture_sample_base_clamp_to_edge_2d_f32) {
-                            auto& sig = builtin->Signature();
-                            auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
-                            if (auto* stex = tex->Type()->As<type::SampledTexture>()) {
-                                if (stex->type()->Is<type::F32>()) {
-                                    fn = builtin_polyfills.GetOrCreate(builtin, [&] {
-                                        return s.textureSampleBaseClampToEdge_2d_f32();
-                                    });
-                                }
-                            }
-                        }
-                        break;
-                    case sem::BuiltinType::kTextureStore:
-                        if (polyfill.bgra8unorm) {
-                            auto& sig = builtin->Signature();
-                            auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
-                            if (auto* stex = tex->Type()->As<type::StorageTexture>()) {
-                                if (stex->texel_format() == builtin::TexelFormat::kBgra8Unorm) {
-                                    size_t value_idx = static_cast<size_t>(
-                                        sig.IndexOf(sem::ParameterUsage::kValue));
-                                    ctx.Replace(expr, [&ctx, expr, value_idx] {
-                                        utils::Vector<const ast::Expression*, 3> args;
-                                        for (auto* arg : expr->args) {
-                                            arg = ctx.Clone(arg);
-                                            if (args.Length() == value_idx) {  // value
-                                                arg = ctx.dst->MemberAccessor(arg, "bgra");
-                                            }
-                                            args.Push(arg);
-                                        }
-                                        return ctx.dst->Call(
-                                            utils::ToString(sem::BuiltinType::kTextureStore),
-                                            std::move(args));
-                                    });
-                                    made_changes = true;
-                                }
-                            }
-                        }
-                        break;
-                    case sem::BuiltinType::kQuantizeToF16:
-                        if (polyfill.quantize_to_vec_f16) {
-                            if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
-                                fn = builtin_polyfills.GetOrCreate(
-                                    builtin, [&] { return s.quantizeToF16(vec); });
-                            }
-                        }
-                        break;
-
-                    case sem::BuiltinType::kWorkgroupUniformLoad:
-                        if (polyfill.workgroup_uniform_load) {
-                            fn = builtin_polyfills.GetOrCreate(builtin, [&] {
-                                return s.workgroupUniformLoad(builtin->ReturnType());
-                            });
-                        }
-                        break;
-
-                    default:
-                        break;
-                }
-
-                if (fn.IsValid()) {
-                    ctx.Replace(call->Declaration(), [&ctx, fn, expr] {
-                        return ctx.dst->Call(fn, ctx.Clone(expr->args));
-                    });
-                    made_changes = true;
-                }
-            },
-            [&](const ast::BinaryExpression* bin_op) {
-                if (auto* sem = src->Sem().Get(bin_op);
-                    !sem || sem->Stage() == sem::EvaluationStage::kConstant ||
-                    sem->Stage() == sem::EvaluationStage::kNotEvaluated) {
-                    return;  // Don't polyfill @const expressions
-                }
-                switch (bin_op->op) {
-                    case ast::BinaryOp::kShiftLeft:
-                    case ast::BinaryOp::kShiftRight: {
-                        if (polyfill.bitshift_modulo) {
-                            ctx.Replace(bin_op, [bin_op, &s] { return s.BitshiftModulo(bin_op); });
-                            made_changes = true;
-                        }
-                        break;
-                    }
-                    case ast::BinaryOp::kDivide: {
-                        if (polyfill.int_div_mod) {
-                            auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
-                            if (lhs_ty->is_integer_scalar_or_vector()) {
-                                ctx.Replace(bin_op, [bin_op, &s] { return s.IntDivMod(bin_op); });
-                                made_changes = true;
-                            }
-                        }
-                        break;
-                    }
-                    case ast::BinaryOp::kModulo: {
-                        if (polyfill.int_div_mod) {
-                            auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
-                            if (lhs_ty->is_integer_scalar_or_vector()) {
-                                ctx.Replace(bin_op, [bin_op, &s] { return s.IntDivMod(bin_op); });
-                                made_changes = true;
-                            }
-                        }
-                        if (polyfill.precise_float_mod) {
-                            auto* lhs_ty = src->TypeOf(bin_op->lhs)->UnwrapRef();
-                            if (lhs_ty->is_float_scalar_or_vector()) {
-                                ctx.Replace(bin_op,
-                                            [bin_op, &s] { return s.PreciseFloatMod(bin_op); });
-                                made_changes = true;
-                            }
-                        }
-                        break;
-                    }
-                    default:
-                        break;
-                }
-            },
-            [&](const ast::Expression* expr) {
-                if (polyfill.bgra8unorm) {
-                    if (auto* ty_expr = src->Sem().Get<sem::TypeExpression>(expr)) {
-                        if (auto* tex = ty_expr->Type()->As<type::StorageTexture>()) {
-                            if (tex->texel_format() == builtin::TexelFormat::kBgra8Unorm) {
-                                ctx.Replace(expr, [&ctx, tex] {
-                                    return ctx.dst->Expr(ctx.dst->ty.storage_texture(
-                                        tex->dim(), builtin::TexelFormat::kRgba8Unorm,
-                                        tex->access()));
-                                });
-                                made_changes = true;
-                            }
-                        }
-                    }
-                }
-            });
-    }
-
-    if (!made_changes) {
-        return SkipTransform;
-    }
-
-    ctx.Clone();
-    return Program(std::move(b));
+    return State{src, *cfg}.Run();
 }
 
 BuiltinPolyfill::Config::Config(const Builtins& b) : builtins(b) {}
diff --git a/src/tint/transform/builtin_polyfill.h b/src/tint/transform/builtin_polyfill.h
index b070248..dee0bec 100644
--- a/src/tint/transform/builtin_polyfill.h
+++ b/src/tint/transform/builtin_polyfill.h
@@ -57,6 +57,8 @@
         bool count_leading_zeros = false;
         /// Should `countTrailingZeros()` be polyfilled?
         bool count_trailing_zeros = false;
+        /// Should converting f32 to i32 or u32 be polyfilled?
+        bool conv_f32_to_iu32 = false;
         /// What level should `extractBits()` be polyfilled?
         Level extract_bits = Level::kNone;
         /// Should `firstLeadingBit()` be polyfilled?
diff --git a/src/tint/transform/builtin_polyfill_test.cc b/src/tint/transform/builtin_polyfill_test.cc
index 8c0d787..65c1f29 100644
--- a/src/tint/transform/builtin_polyfill_test.cc
+++ b/src/tint/transform/builtin_polyfill_test.cc
@@ -815,6 +815,157 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// conv_f32_to_iu32
+////////////////////////////////////////////////////////////////////////////////
+DataMap polyfillConvF32ToIU32() {
+    BuiltinPolyfill::Builtins builtins;
+    builtins.conv_f32_to_iu32 = true;
+    DataMap data;
+    data.Add<BuiltinPolyfill::Config>(builtins);
+    return data;
+}
+
+TEST_F(BuiltinPolyfillTest, ShouldRunConvF32ToI32) {
+    auto* src = R"(
+fn f() {
+  let f = 42.0;
+  _ = i32(f);
+}
+)";
+
+    EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
+    EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillConvF32ToIU32()));
+}
+
+TEST_F(BuiltinPolyfillTest, ShouldRunConvF32ToU32) {
+    auto* src = R"(
+fn f() {
+  let f = 42.0;
+  _ = u32(f);
+}
+)";
+
+    EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
+    EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillConvF32ToIU32()));
+}
+
+TEST_F(BuiltinPolyfillTest, ShouldRunConvVec3F32ToVec3I32) {
+    auto* src = R"(
+fn f() {
+  let f = vec3(42.0);
+  _ = vec3<i32>(f);
+}
+)";
+
+    EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
+    EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillConvF32ToIU32()));
+}
+
+TEST_F(BuiltinPolyfillTest, ShouldRunConvVec3F32ToVec3U32) {
+    auto* src = R"(
+fn f() {
+  let f = vec3(42.0);
+  _ = vec3<u32>(f);
+}
+)";
+
+    EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
+    EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillConvF32ToIU32()));
+}
+
+TEST_F(BuiltinPolyfillTest, ConvF32ToI32) {
+    auto* src = R"(
+fn f() {
+  let f = 42.0;
+  _ = i32(f);
+}
+)";
+    auto* expect = R"(
+fn tint_ftoi(v : f32) -> i32 {
+  return select(2147483647, select(i32(v), -2147483648, (v < -2147483648.0)), (v < 2147483520.0));
+}
+
+fn f() {
+  let f = 42.0;
+  _ = tint_ftoi(f);
+}
+)";
+
+    auto got = Run<BuiltinPolyfill>(src, polyfillConvF32ToIU32());
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(BuiltinPolyfillTest, ConvF32ToU32) {
+    auto* src = R"(
+fn f() {
+  let f = 42.0;
+  _ = u32(f);
+}
+)";
+    auto* expect = R"(
+fn tint_ftou(v : f32) -> u32 {
+  return select(4294967295, select(u32(v), 0, (v < 0.0)), (v < 4294967040.0));
+}
+
+fn f() {
+  let f = 42.0;
+  _ = tint_ftou(f);
+}
+)";
+
+    auto got = Run<BuiltinPolyfill>(src, polyfillConvF32ToIU32());
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(BuiltinPolyfillTest, ConvVec3F32ToVec3I32) {
+    auto* src = R"(
+fn f() {
+  let f = vec3(42.0);
+  _ = vec3<i32>(f);
+}
+)";
+    auto* expect = R"(
+fn tint_ftoi(v : vec3<f32>) -> vec3<i32> {
+  return select(vec3(2147483647), select(vec3<i32>(v), vec3(-2147483648), (v < vec3(-2147483648.0))), (v < vec3(2147483520.0)));
+}
+
+fn f() {
+  let f = vec3(42.0);
+  _ = tint_ftoi(f);
+}
+)";
+
+    auto got = Run<BuiltinPolyfill>(src, polyfillConvF32ToIU32());
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(BuiltinPolyfillTest, ConvVec3F32ToVec3U32) {
+    auto* src = R"(
+fn f() {
+  let f = vec3(42.0);
+  _ = vec3<u32>(f);
+}
+)";
+    auto* expect = R"(
+fn tint_ftou(v : vec3<f32>) -> vec3<u32> {
+  return select(vec3(4294967295), select(vec3<u32>(v), vec3(0), (v < vec3(0.0))), (v < vec3(4294967040.0)));
+}
+
+fn f() {
+  let f = vec3(42.0);
+  _ = tint_ftou(f);
+}
+)";
+
+    auto got = Run<BuiltinPolyfill>(src, polyfillConvF32ToIU32());
+
+    EXPECT_EQ(expect, str(got));
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // countLeadingZeros
 ////////////////////////////////////////////////////////////////////////////////
 DataMap polyfillCountLeadingZeros() {
diff --git a/src/tint/transform/calculate_array_length.cc b/src/tint/transform/calculate_array_length.cc
index 9f5b659..743a992 100644
--- a/src/tint/transform/calculate_array_length.cc
+++ b/src/tint/transform/calculate_array_length.cc
@@ -26,6 +26,7 @@
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/struct.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/simplify_pointers.h"
 #include "src/tint/type/reference.h"
 #include "src/tint/utils/hash.h"
@@ -44,7 +45,7 @@
     for (auto* fn : program->AST().Functions()) {
         if (auto* sem_fn = program->Sem().Get(fn)) {
             for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
-                if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+                if (builtin->Type() == builtin::Function::kArrayLength) {
                     return true;
                 }
             }
@@ -130,7 +131,7 @@
         if (auto* call_expr = node->As<ast::CallExpression>()) {
             auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
             if (auto* builtin = call->Target()->As<sem::Builtin>()) {
-                if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+                if (builtin->Type() == builtin::Function::kArrayLength) {
                     // We're dealing with an arrayLength() call
 
                     if (auto* call_stmt = call->Stmt()->Declaration()->As<ast::CallStatement>()) {
diff --git a/src/tint/transform/combine_samplers.cc b/src/tint/transform/combine_samplers.cc
index 7b9f9fd..ca8111c 100644
--- a/src/tint/transform/combine_samplers.cc
+++ b/src/tint/transform/combine_samplers.cc
@@ -276,7 +276,7 @@
                         }
                     }
                     const ast::Expression* value = ctx.dst->Call(ctx.Clone(expr->target), args);
-                    if (builtin->Type() == sem::BuiltinType::kTextureLoad &&
+                    if (builtin->Type() == builtin::Function::kTextureLoad &&
                         texture_var->Type()->UnwrapRef()->Is<type::DepthTexture>() &&
                         !call->Stmt()->Declaration()->Is<ast::CallStatement>()) {
                         value = ctx.dst->MemberAccessor(value, "x");
diff --git a/src/tint/transform/decompose_memory_access.cc b/src/tint/transform/decompose_memory_access.cc
index f3d92c5..f2146f3 100644
--- a/src/tint/transform/decompose_memory_access.cc
+++ b/src/tint/transform/decompose_memory_access.cc
@@ -30,6 +30,7 @@
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/struct.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/array.h"
 #include "src/tint/type/atomic.h"
 #include "src/tint/type/reference.h"
@@ -124,7 +125,7 @@
 /// AtomicKey is the unordered map key to an atomic intrinsic.
 struct AtomicKey {
     type::Type const* el_ty = nullptr;  // element type
-    sem::BuiltinType const op;          // atomic op
+    builtin::Function const op;         // atomic op
     Symbol const buffer;                // buffer name
     bool operator==(const AtomicKey& rhs) const {
         return el_ty == rhs.el_ty && op == rhs.op && buffer == rhs.buffer;
@@ -248,42 +249,42 @@
 /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function for
 /// the atomic op and the type @p ty.
 DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
-                                                     sem::BuiltinType ity,
+                                                     builtin::Function ity,
                                                      const type::Type* ty,
                                                      const Symbol& buffer) {
     auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
     switch (ity) {
-        case sem::BuiltinType::kAtomicLoad:
+        case builtin::Function::kAtomicLoad:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
             break;
-        case sem::BuiltinType::kAtomicStore:
+        case builtin::Function::kAtomicStore:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicStore;
             break;
-        case sem::BuiltinType::kAtomicAdd:
+        case builtin::Function::kAtomicAdd:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAdd;
             break;
-        case sem::BuiltinType::kAtomicSub:
+        case builtin::Function::kAtomicSub:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicSub;
             break;
-        case sem::BuiltinType::kAtomicMax:
+        case builtin::Function::kAtomicMax:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMax;
             break;
-        case sem::BuiltinType::kAtomicMin:
+        case builtin::Function::kAtomicMin:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMin;
             break;
-        case sem::BuiltinType::kAtomicAnd:
+        case builtin::Function::kAtomicAnd:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAnd;
             break;
-        case sem::BuiltinType::kAtomicOr:
+        case builtin::Function::kAtomicOr:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicOr;
             break;
-        case sem::BuiltinType::kAtomicXor:
+        case builtin::Function::kAtomicXor:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicXor;
             break;
-        case sem::BuiltinType::kAtomicExchange:
+        case builtin::Function::kAtomicExchange:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicExchange;
             break;
-        case sem::BuiltinType::kAtomicCompareExchangeWeak:
+        case builtin::Function::kAtomicCompareExchangeWeak:
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicCompareExchangeWeak;
             break;
         default:
@@ -658,7 +659,7 @@
             ast::Type ret_ty;
 
             // For intrinsics that return a struct, there is no AST node for it, so create one now.
-            if (intrinsic->Type() == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+            if (intrinsic->Type() == builtin::Function::kAtomicCompareExchangeWeak) {
                 auto* str = intrinsic->ReturnType()->As<sem::Struct>();
                 TINT_ASSERT(Transform, str && str->Declaration() == nullptr);
 
@@ -937,7 +938,7 @@
         if (auto* call_expr = node->As<ast::CallExpression>()) {
             auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
             if (auto* builtin = call->Target()->As<sem::Builtin>()) {
-                if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+                if (builtin->Type() == builtin::Function::kArrayLength) {
                     // arrayLength(X)
                     // Don't convert X into a load, this builtin actually requires the real pointer.
                     state.TakeAccess(call_expr->args[0]);
diff --git a/src/tint/transform/demote_to_helper.cc b/src/tint/transform/demote_to_helper.cc
index ac3c15e..c853ef0 100644
--- a/src/tint/transform/demote_to_helper.cc
+++ b/src/tint/transform/demote_to_helper.cc
@@ -23,6 +23,7 @@
 #include "src/tint/sem/call.h"
 #include "src/tint/sem/function.h"
 #include "src/tint/sem/statement.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/utils/hoist_to_decl_before.h"
 #include "src/tint/type/reference.h"
 #include "src/tint/utils/map.h"
@@ -152,13 +153,13 @@
                     return;
                 }
 
-                if (builtin->Type() == sem::BuiltinType::kTextureStore) {
+                if (builtin->Type() == builtin::Function::kTextureStore) {
                     // A call to textureStore() will always be a statement.
                     // Wrap it inside a conditional block.
                     auto* masked_call = b.If(b.Not(flag), b.Block(ctx.Clone(stmt->Declaration())));
                     ctx.Replace(stmt->Declaration(), masked_call);
                 } else if (builtin->IsAtomic() &&
-                           builtin->Type() != sem::BuiltinType::kAtomicLoad) {
+                           builtin->Type() != builtin::Function::kAtomicLoad) {
                     // A call to an atomic builtin can be a statement or an expression.
                     if (auto* call_stmt = stmt->Declaration()->As<ast::CallStatement>();
                         call_stmt && call_stmt->expr == call) {
@@ -179,7 +180,7 @@
                         auto result = b.Sym();
                         ast::Type result_ty;
                         const ast::Statement* masked_call = nullptr;
-                        if (builtin->Type() == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+                        if (builtin->Type() == builtin::Function::kAtomicCompareExchangeWeak) {
                             // Special case for atomicCompareExchangeWeak as we cannot name its
                             // result type. We have to declare an equivalent struct and copy the
                             // original member values over to it.
diff --git a/src/tint/transform/merge_return.cc b/src/tint/transform/merge_return.cc
index 353fb13..f9f2feb 100644
--- a/src/tint/transform/merge_return.cc
+++ b/src/tint/transform/merge_return.cc
@@ -18,6 +18,7 @@
 
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/statement.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/scoped_assignment.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::MergeReturn);
diff --git a/src/tint/transform/multiplanar_external_texture.cc b/src/tint/transform/multiplanar_external_texture.cc
index 27eeeb0..310bc46 100644
--- a/src/tint/transform/multiplanar_external_texture.cc
+++ b/src/tint/transform/multiplanar_external_texture.cc
@@ -121,7 +121,7 @@
             // The binding points for the newly introduced bindings must have been provided to this
             // transform. We fetch the new binding points by providing the original texture_external
             // binding points into the passed map.
-            BindingPoint bp = sem_var->BindingPoint();
+            sem::BindingPoint bp = sem_var->BindingPoint();
 
             BindingsMap::const_iterator it = new_binding_points->bindings_map.find(bp);
             if (it == new_binding_points->bindings_map.end()) {
@@ -196,7 +196,7 @@
 
             if (builtin && !builtin->Parameters().IsEmpty() &&
                 builtin->Parameters()[0]->Type()->Is<type::ExternalTexture>() &&
-                builtin->Type() != sem::BuiltinType::kTextureDimensions) {
+                builtin->Type() != builtin::Function::kTextureDimensions) {
                 if (auto* var_user =
                         sem.GetVal(expr->args[0])->UnwrapLoad()->As<sem::VariableUser>()) {
                     auto it = new_binding_symbols.find(var_user->Variable());
@@ -210,9 +210,9 @@
                     auto& syms = it->second;
 
                     switch (builtin->Type()) {
-                        case sem::BuiltinType::kTextureLoad:
+                        case builtin::Function::kTextureLoad:
                             return createTextureLoad(call, syms);
-                        case sem::BuiltinType::kTextureSampleBaseClampToEdge:
+                        case builtin::Function::kTextureSampleBaseClampToEdge:
                             return createTextureSampleBaseClampToEdge(expr, syms);
                         default:
                             break;
@@ -310,13 +310,13 @@
     /// builtin function.
     /// @param call_type determines which function body to generate
     /// @returns a statement list that makes of the body of the chosen function
-    auto buildTextureBuiltinBody(sem::BuiltinType call_type) {
+    auto buildTextureBuiltinBody(builtin::Function call_type) {
         utils::Vector<const ast::Statement*, 16> stmts;
         const ast::CallExpression* single_plane_call = nullptr;
         const ast::CallExpression* plane_0_call = nullptr;
         const ast::CallExpression* plane_1_call = nullptr;
         switch (call_type) {
-            case sem::BuiltinType::kTextureSampleBaseClampToEdge:
+            case builtin::Function::kTextureSampleBaseClampToEdge:
                 stmts.Push(b.Decl(b.Let(
                     "modifiedCoords", b.Mul(b.MemberAccessor("params", "coordTransformationMatrix"),
                                             b.vec3<f32>("coord", 1_a)))));
@@ -346,7 +346,7 @@
                 // textureSampleLevel(plane1, smp, plane1_clamped, 0.0);
                 plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "plane1_clamped", 0_a);
                 break;
-            case sem::BuiltinType::kTextureLoad:
+            case builtin::Function::kTextureLoad:
                 // textureLoad(plane0, coord, 0);
                 single_plane_call = b.Call("textureLoad", "plane0", "coord", 0_a);
                 // textureLoad(plane0, coord, 0);
@@ -433,7 +433,7 @@
                        b.Param("params", b.ty(params_struct_sym)),
                    },
                    b.ty.vec4(b.ty.f32()),
-                   buildTextureBuiltinBody(sem::BuiltinType::kTextureSampleBaseClampToEdge));
+                   buildTextureBuiltinBody(builtin::Function::kTextureSampleBaseClampToEdge));
         }
 
         return b.Call(texture_sample_external_sym, utils::Vector{
@@ -480,7 +480,7 @@
                        b.Param("params", b.ty(params_struct_sym)),
                    },
                    b.ty.vec4(b.ty.f32()),  //
-                   buildTextureBuiltinBody(sem::BuiltinType::kTextureLoad));
+                   buildTextureBuiltinBody(builtin::Function::kTextureLoad));
 
             return name;
         });
@@ -494,6 +494,7 @@
 
 MultiplanarExternalTexture::NewBindingPoints::NewBindingPoints(BindingsMap inputBindingsMap)
     : bindings_map(std::move(inputBindingsMap)) {}
+
 MultiplanarExternalTexture::NewBindingPoints::~NewBindingPoints() = default;
 
 MultiplanarExternalTexture::MultiplanarExternalTexture() = default;
diff --git a/src/tint/transform/multiplanar_external_texture.h b/src/tint/transform/multiplanar_external_texture.h
index 695e38c..656d0ad 100644
--- a/src/tint/transform/multiplanar_external_texture.h
+++ b/src/tint/transform/multiplanar_external_texture.h
@@ -19,15 +19,13 @@
 #include <utility>
 
 #include "src/tint/ast/struct_member.h"
+#include "src/tint/builtin/function.h"
 #include "src/tint/sem/binding_point.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/sem/external_texture.h"
 #include "src/tint/transform/transform.h"
 
 namespace tint::transform {
 
-/// BindingPoint is an alias to sem::BindingPoint
-using BindingPoint = sem::BindingPoint;
-
 /// Within the MultiplanarExternalTexture transform, each instance of a
 /// texture_external binding is unpacked into two texture_2d<f32> bindings
 /// representing two possible planes of a texture and a uniform buffer binding
@@ -43,22 +41,12 @@
   public:
     /// This struct identifies the binding groups and locations for new bindings to
     /// use when transforming a texture_external instance.
-    struct BindingPoints {
-        /// The desired binding location of the texture_2d representing plane #1 when
-        /// a texture_external binding is expanded.
-        BindingPoint plane_1;
-        /// The desired binding location of the ExternalTextureParams uniform when a
-        /// texture_external binding is expanded.
-        BindingPoint params;
-
-        /// Reflect the fields of this class so that it can be used by tint::ForeachField()
-        TINT_REFLECT(plane_1, params);
-    };
+    using BindingPoints = sem::external_texture::BindingPoints;
 
     /// BindingsMap is a map where the key is the binding location of a
     /// texture_external and the value is a struct containing the desired
     /// locations for new bindings expanded from the texture_external instance.
-    using BindingsMap = std::unordered_map<BindingPoint, BindingPoints>;
+    using BindingsMap = sem::external_texture::BindingsMap;
 
     /// NewBindingPoints is consumed by the MultiplanarExternalTexture transform.
     /// Data holds information about location of each texture_external binding and
diff --git a/src/tint/transform/packed_vec3.cc b/src/tint/transform/packed_vec3.cc
index 956adcb..8a23221 100644
--- a/src/tint/transform/packed_vec3.cc
+++ b/src/tint/transform/packed_vec3.cc
@@ -27,6 +27,7 @@
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/type_expression.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/array.h"
 #include "src/tint/type/reference.h"
 #include "src/tint/type/vector.h"
diff --git a/src/tint/transform/preserve_padding.cc b/src/tint/transform/preserve_padding.cc
index fbe785c..e8c95e3 100644
--- a/src/tint/transform/preserve_padding.cc
+++ b/src/tint/transform/preserve_padding.cc
@@ -19,6 +19,7 @@
 
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/struct.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/reference.h"
 #include "src/tint/utils/map.h"
 #include "src/tint/utils/vector.h"
@@ -66,8 +67,8 @@
                 },
                 [&](const ast::Enable* enable) {
                     // Check if the full pointer parameters extension is already enabled.
-                    if (enable->extension ==
-                        builtin::Extension::kChromiumExperimentalFullPtrParameters) {
+                    if (enable->HasExtension(
+                            builtin::Extension::kChromiumExperimentalFullPtrParameters)) {
                         ext_enabled = true;
                     }
                 });
diff --git a/src/tint/transform/promote_side_effects_to_decl.cc b/src/tint/transform/promote_side_effects_to_decl.cc
index 65ec731..9db7e38 100644
--- a/src/tint/transform/promote_side_effects_to_decl.cc
+++ b/src/tint/transform/promote_side_effects_to_decl.cc
@@ -337,9 +337,8 @@
             });
     }
 
-    // Starts the recursive processing of a statement's expression(s) to hoist
-    // side-effects to lets.
-    void ProcessStatement(const ast::Expression* expr) {
+    // Starts the recursive processing of a statement's expression(s) to hoist side-effects to lets.
+    void ProcessExpression(const ast::Expression* expr) {
         if (!expr) {
             return;
         }
@@ -348,31 +347,6 @@
         ProcessExpression(expr, maybe_hoist);
     }
 
-    // Special case for processing assignment statement expressions, as we must
-    // evaluate the rhs before the lhs, and possibly hoist the rhs expression.
-    void ProcessAssignment(const ast::Expression* lhs, const ast::Expression* rhs) {
-        // Evaluate rhs before lhs
-        tint::utils::Vector<const ast::Expression*, 8> maybe_hoist;
-        if (ProcessExpression(rhs, maybe_hoist)) {
-            maybe_hoist.Push(rhs);
-        }
-
-        // If the rhs has side-effects, it may affect the lhs, so hoist it right
-        // away. e.g. "b[c] = a(0);"
-        if (HasSideEffects(rhs)) {
-            // Technically, we can always hoist rhs, but don't bother doing so when
-            // the lhs is just a variable or phony.
-            if (!lhs->IsAnyOf<ast::IdentifierExpression, ast::PhonyExpression>()) {
-                Flush(maybe_hoist);
-            }
-        }
-
-        // If maybe_hoist still has values, it means they are potential side-effect
-        // receivers. We pass this in while processing the lhs, in which case they
-        // may get hoisted if the lhs has side-effects. E.g. "b[a(0)] = c;".
-        ProcessExpression(lhs, maybe_hoist);
-    }
-
   public:
     explicit CollectHoistsState(CloneContext& ctx_in) : StateBase(ctx_in) {}
 
@@ -386,21 +360,26 @@
             }
 
             Switch(
-                stmt, [&](const ast::AssignmentStatement* s) { ProcessAssignment(s->lhs, s->rhs); },
-                [&](const ast::CallStatement* s) {  //
-                    ProcessStatement(s->expr);
+                stmt,  //
+                [&](const ast::AssignmentStatement* s) {
+                    tint::utils::Vector<const ast::Expression*, 8> maybe_hoist;
+                    ProcessExpression(s->lhs, maybe_hoist);
+                    ProcessExpression(s->rhs, maybe_hoist);
                 },
-                [&](const ast::ForLoopStatement* s) { ProcessStatement(s->condition); },
-                [&](const ast::WhileStatement* s) { ProcessStatement(s->condition); },
+                [&](const ast::CallStatement* s) {  //
+                    ProcessExpression(s->expr);
+                },
+                [&](const ast::ForLoopStatement* s) { ProcessExpression(s->condition); },
+                [&](const ast::WhileStatement* s) { ProcessExpression(s->condition); },
                 [&](const ast::IfStatement* s) {  //
-                    ProcessStatement(s->condition);
+                    ProcessExpression(s->condition);
                 },
                 [&](const ast::ReturnStatement* s) {  //
-                    ProcessStatement(s->value);
+                    ProcessExpression(s->value);
                 },
-                [&](const ast::SwitchStatement* s) { ProcessStatement(s->condition); },
+                [&](const ast::SwitchStatement* s) { ProcessExpression(s->condition); },
                 [&](const ast::VariableDeclStatement* s) {
-                    ProcessStatement(s->variable->initializer);
+                    ProcessExpression(s->variable->initializer);
                 });
         }
 
@@ -563,10 +542,10 @@
                     !sem.GetVal(s->rhs)->HasSideEffects()) {
                     return nullptr;
                 }
-                // rhs before lhs
+                // lhs before rhs
                 tint::utils::Vector<const ast::Statement*, 8> stmts;
-                ctx.Replace(s->rhs, Decompose(s->rhs, &stmts));
                 ctx.Replace(s->lhs, Decompose(s->lhs, &stmts));
+                ctx.Replace(s->rhs, Decompose(s->rhs, &stmts));
                 InsertBefore(stmts, s);
                 return ctx.CloneWithoutTransform(s);
             },
diff --git a/src/tint/transform/promote_side_effects_to_decl_test.cc b/src/tint/transform/promote_side_effects_to_decl_test.cc
index 6ed4b27..636a809 100644
--- a/src/tint/transform/promote_side_effects_to_decl_test.cc
+++ b/src/tint/transform/promote_side_effects_to_decl_test.cc
@@ -2830,9 +2830,8 @@
 
 fn f() {
   var b = array<i32, 10>();
-  let tint_symbol = a(1);
-  let tint_symbol_1 = a(0);
-  b[tint_symbol_1] = tint_symbol;
+  let tint_symbol = a(0);
+  b[tint_symbol] = a(1);
 }
 )";
 
@@ -2861,10 +2860,9 @@
 
 fn f() {
   var b = array<array<i32, 10>, 10>();
-  let tint_symbol = a(2);
-  let tint_symbol_1 = a(0);
-  let tint_symbol_2 = a(1);
-  b[tint_symbol_1][tint_symbol_2] = tint_symbol;
+  let tint_symbol = a(0);
+  let tint_symbol_1 = a(1);
+  b[tint_symbol][tint_symbol_1] = a(2);
 }
 )";
 
@@ -2893,11 +2891,10 @@
 
 fn f() {
   var b = array<array<array<i32, 10>, 10>, 10>();
-  let tint_symbol = a(3);
-  let tint_symbol_1 = a(0);
-  let tint_symbol_2 = a(1);
-  let tint_symbol_3 = a(2);
-  b[tint_symbol_1][tint_symbol_2][tint_symbol_3] = tint_symbol;
+  let tint_symbol = a(0);
+  let tint_symbol_1 = a(1);
+  let tint_symbol_2 = a(2);
+  b[tint_symbol][tint_symbol_1][tint_symbol_2] = a(3);
 }
 )";
 
@@ -2930,11 +2927,9 @@
   var b = array<i32, 3>();
   var d = array<array<i32, 3>, 3>();
   var a_1 = 0;
-  let tint_symbol = a(0);
-  let tint_symbol_1 = a_1;
-  let tint_symbol_2 = d[tint_symbol][tint_symbol_1];
-  let tint_symbol_3 = a(2);
-  b[tint_symbol_3] = tint_symbol_2;
+  let tint_symbol = a(2);
+  let tint_symbol_1 = a(0);
+  b[tint_symbol] = d[tint_symbol_1][a_1];
 }
 )";
 
@@ -2963,9 +2958,8 @@
 
 fn f() {
   var b = vec3<i32>();
-  let tint_symbol = a(1);
-  let tint_symbol_1 = a(0);
-  b[tint_symbol_1] = tint_symbol;
+  let tint_symbol = a(0);
+  b[tint_symbol] = a(1);
 }
 )";
 
@@ -2996,9 +2990,8 @@
 fn f() {
   var b = vec3<i32>();
   var c = 0;
-  let tint_symbol = c;
-  let tint_symbol_1 = a(0);
-  b[tint_symbol_1] = tint_symbol;
+  let tint_symbol = a(0);
+  b[tint_symbol] = c;
 }
 )";
 
@@ -3029,8 +3022,8 @@
 fn f() {
   var b = vec3<i32>();
   var c = 0;
-  let tint_symbol = a(0);
-  b[c] = tint_symbol;
+  let tint_symbol = c;
+  b[tint_symbol] = a(0);
 }
 )";
 
diff --git a/src/tint/transform/renamer.cc b/src/tint/transform/renamer.cc
index 3ddb6c6..708c6ec 100644
--- a/src/tint/transform/renamer.cc
+++ b/src/tint/transform/renamer.cc
@@ -24,6 +24,7 @@
 #include "src/tint/sem/type_expression.h"
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
+#include "src/tint/switch.h"
 #include "src/tint/text/unicode.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::Renamer);
diff --git a/src/tint/transform/robustness.cc b/src/tint/transform/robustness.cc
index b79a029..2eb74a1 100644
--- a/src/tint/transform/robustness.cc
+++ b/src/tint/transform/robustness.cc
@@ -28,6 +28,7 @@
 #include "src/tint/sem/member_accessor_expression.h"
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/utils/hoist_to_decl_before.h"
 #include "src/tint/type/reference.h"
 
@@ -231,7 +232,7 @@
                     // Must clamp, even if the index is constant.
 
                     auto* arr_ptr = b.AddressOf(ctx.Clone(expr->Object()->Declaration()));
-                    return b.Sub(b.Call(sem::BuiltinType::kArrayLength, arr_ptr), 1_u);
+                    return b.Sub(b.Call(builtin::Function::kArrayLength, arr_ptr), 1_u);
                 }
                 if (auto count = arr->ConstantCount()) {
                     if (expr->Index()->ConstantValue()) {
@@ -343,7 +344,7 @@
         if (expr_sem->Index()->Type()->is_signed_integer_scalar()) {
             idx = b.Call<u32>(idx);  // u32(idx)
         }
-        auto* clamped_idx = b.Call(sem::BuiltinType::kMin, idx, max);
+        auto* clamped_idx = b.Call(builtin::Function::kMin, idx, max);
         ctx.Replace(expr->Declaration()->index, clamped_idx);
     }
 
@@ -358,14 +359,14 @@
         }
 
         if (predicate) {
-            if (builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+            if (builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
                 // https://www.w3.org/TR/WGSL/#workgroupUniformLoad-builtin:
                 //  "Executes a control barrier synchronization function that affects memory and
                 //   atomic operations in the workgroup address space."
                 // Because the call acts like a control barrier, we need to make sure that we still
                 // trigger a workgroup barrier if the predicate fails.
                 PredicateCall(call, predicate,
-                              b.Block(b.CallStmt(b.Call(sem::BuiltinType::kWorkgroupBarrier))));
+                              b.Block(b.CallStmt(b.Call(builtin::Function::kWorkgroupBarrier))));
             } else {
                 PredicateCall(call, predicate);
             }
@@ -408,7 +409,7 @@
                 // let num_levels = textureNumLevels(texture-arg);
                 num_levels = b.Symbols().New("num_levels");
                 hoist.InsertBefore(
-                    stmt, b.Decl(b.Let(num_levels, b.Call(sem::BuiltinType::kTextureNumLevels,
+                    stmt, b.Decl(b.Let(num_levels, b.Call(builtin::Function::kTextureNumLevels,
                                                           ctx.Clone(texture_arg)))));
 
                 // predicate: level_idx < num_levels
@@ -433,12 +434,12 @@
                 // predicate: all(coords < textureDimensions(texture))
                 auto* dimensions =
                     level_idx.IsValid()
-                        ? b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg),
-                                 b.Call(sem::BuiltinType::kMin, b.Expr(level_idx),
+                        ? b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg),
+                                 b.Call(builtin::Function::kMin, b.Expr(level_idx),
                                         b.Sub(num_levels, 1_a)))
-                        : b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg));
+                        : b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg));
                 predicate =
-                    And(predicate, b.Call(sem::BuiltinType::kAll, b.LessThan(coords, dimensions)));
+                    And(predicate, b.Call(builtin::Function::kAll, b.LessThan(coords, dimensions)));
 
                 // Replace the level argument with `coord`
                 ctx.Replace(arg, b.Expr(coords));
@@ -448,7 +449,7 @@
         if (array_arg_idx >= 0) {
             // let array_idx = u32(array-arg)
             auto* arg = expr->args[static_cast<size_t>(array_arg_idx)];
-            auto* num_layers = b.Call(sem::BuiltinType::kTextureNumLayers, ctx.Clone(texture_arg));
+            auto* num_layers = b.Call(builtin::Function::kTextureNumLayers, ctx.Clone(texture_arg));
             auto array_idx = b.Symbols().New("array_idx");
             hoist.InsertBefore(stmt, b.Decl(b.Let(array_idx, CastToUnsigned(ctx.Clone(arg), 1u))));
 
@@ -493,10 +494,10 @@
                 const auto* arg = expr->args[static_cast<size_t>(level_arg_idx)];
                 level_idx = b.Symbols().New("level_idx");
                 const auto* num_levels =
-                    b.Call(sem::BuiltinType::kTextureNumLevels, ctx.Clone(texture_arg));
+                    b.Call(builtin::Function::kTextureNumLevels, ctx.Clone(texture_arg));
                 const auto* max = b.Sub(num_levels, 1_a);
                 hoist.InsertBefore(
-                    stmt, b.Decl(b.Let(level_idx, b.Call(sem::BuiltinType::kMin,
+                    stmt, b.Decl(b.Let(level_idx, b.Call(builtin::Function::kMin,
                                                          b.Call<u32>(ctx.Clone(arg)), max))));
                 ctx.Replace(arg, b.Expr(level_idx));
             }
@@ -510,19 +511,19 @@
                 const auto width = WidthOf(param->Type());
                 const auto* dimensions =
                     level_idx.IsValid()
-                        ? b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg),
+                        ? b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg),
                                  level_idx)
-                        : b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg));
+                        : b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg));
 
                 // dimensions is u32 or vecN<u32>
                 const auto* unsigned_max = b.Sub(dimensions, ScalarOrVec(b.Expr(1_a), width));
                 if (param->Type()->is_signed_integer_scalar_or_vector()) {
                     const auto* zero = ScalarOrVec(b.Expr(0_a), width);
                     const auto* signed_max = CastToSigned(unsigned_max, width);
-                    ctx.Replace(arg,
-                                b.Call(sem::BuiltinType::kClamp, ctx.Clone(arg), zero, signed_max));
+                    ctx.Replace(
+                        arg, b.Call(builtin::Function::kClamp, ctx.Clone(arg), zero, signed_max));
                 } else {
-                    ctx.Replace(arg, b.Call(sem::BuiltinType::kMin, ctx.Clone(arg), unsigned_max));
+                    ctx.Replace(arg, b.Call(builtin::Function::kMin, ctx.Clone(arg), unsigned_max));
                 }
             }
         }
@@ -531,14 +532,15 @@
         if (array_arg_idx >= 0) {
             auto* param = builtin->Parameters()[static_cast<size_t>(array_arg_idx)];
             auto* arg = expr->args[static_cast<size_t>(array_arg_idx)];
-            auto* num_layers = b.Call(sem::BuiltinType::kTextureNumLayers, ctx.Clone(texture_arg));
+            auto* num_layers = b.Call(builtin::Function::kTextureNumLayers, ctx.Clone(texture_arg));
 
             const auto* unsigned_max = b.Sub(num_layers, 1_a);
             if (param->Type()->is_signed_integer_scalar()) {
                 const auto* signed_max = CastToSigned(unsigned_max, 1u);
-                ctx.Replace(arg, b.Call(sem::BuiltinType::kClamp, ctx.Clone(arg), 0_a, signed_max));
+                ctx.Replace(arg,
+                            b.Call(builtin::Function::kClamp, ctx.Clone(arg), 0_a, signed_max));
             } else {
-                ctx.Replace(arg, b.Call(sem::BuiltinType::kMin, ctx.Clone(arg), unsigned_max));
+                ctx.Replace(arg, b.Call(builtin::Function::kMin, ctx.Clone(arg), unsigned_max));
             }
         }
     }
@@ -546,9 +548,10 @@
     /// @param type builtin type
     /// @returns true if the given builtin is a texture function that requires predication or
     /// clamping of arguments.
-    bool TextureBuiltinNeedsRobustness(sem::BuiltinType type) {
-        return type == sem::BuiltinType::kTextureLoad || type == sem::BuiltinType::kTextureStore ||
-               type == sem::BuiltinType::kTextureDimensions;
+    bool TextureBuiltinNeedsRobustness(builtin::Function type) {
+        return type == builtin::Function::kTextureLoad ||
+               type == builtin::Function::kTextureStore ||
+               type == builtin::Function::kTextureDimensions;
     }
 
     /// @returns a bitwise and of the two expressions, or the other expression if one is null.
diff --git a/src/tint/transform/simplify_pointers.cc b/src/tint/transform/simplify_pointers.cc
index e9c719e..bec9019 100644
--- a/src/tint/transform/simplify_pointers.cc
+++ b/src/tint/transform/simplify_pointers.cc
@@ -24,6 +24,7 @@
 #include "src/tint/sem/function.h"
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/unshadow.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::SimplifyPointers);
diff --git a/src/tint/transform/single_entry_point.cc b/src/tint/transform/single_entry_point.cc
index 8a8daeb..8be90bb 100644
--- a/src/tint/transform/single_entry_point.cc
+++ b/src/tint/transform/single_entry_point.cc
@@ -20,6 +20,7 @@
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/function.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::SingleEntryPoint);
 TINT_INSTANTIATE_TYPEINFO(tint::transform::SingleEntryPoint::Config);
diff --git a/src/tint/transform/spirv_atomic.cc b/src/tint/transform/spirv_atomic.cc
index 043861b..f41fbb7 100644
--- a/src/tint/transform/spirv_atomic.cc
+++ b/src/tint/transform/spirv_atomic.cc
@@ -26,6 +26,7 @@
 #include "src/tint/sem/index_accessor_expression.h"
 #include "src/tint/sem/member_accessor_expression.h"
 #include "src/tint/sem/statement.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/reference.h"
 #include "src/tint/utils/map.h"
 #include "src/tint/utils/unique_vector.h"
@@ -81,22 +82,22 @@
                     out_args[0] = b.AddressOf(out_args[0]);
 
                     // Replace all callsites of this stub to a call to the real builtin
-                    if (stub->builtin == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+                    if (stub->builtin == builtin::Function::kAtomicCompareExchangeWeak) {
                         // atomicCompareExchangeWeak returns a struct, so insert a call to it above
                         // the current statement, and replace the current call with the struct's
                         // `old_value` member.
                         auto* block = call->Stmt()->Block()->Declaration();
                         auto old_value = b.Symbols().New("old_value");
                         auto old_value_decl = b.Decl(b.Let(
-                            old_value,
-                            b.MemberAccessor(b.Call(sem::str(stub->builtin), std::move(out_args)),
-                                             "old_value")));
+                            old_value, b.MemberAccessor(
+                                           b.Call(builtin::str(stub->builtin), std::move(out_args)),
+                                           "old_value")));
                         ctx.InsertBefore(block->statements, call->Stmt()->Declaration(),
                                          old_value_decl);
                         ctx.Replace(call->Declaration(), b.Expr(old_value));
                     } else {
                         ctx.Replace(call->Declaration(),
-                                    b.Call(sem::str(stub->builtin), std::move(out_args)));
+                                    b.Call(builtin::str(stub->builtin), std::move(out_args)));
                     }
 
                     // Keep track of this expression. We'll need to modify the root identifier /
@@ -255,7 +256,7 @@
                             ctx.Replace(assign, [=] {
                                 auto* lhs = ctx.CloneWithoutTransform(assign->lhs);
                                 auto* rhs = ctx.CloneWithoutTransform(assign->rhs);
-                                auto* call = b.Call(sem::str(sem::BuiltinType::kAtomicStore),
+                                auto* call = b.Call(builtin::str(builtin::Function::kAtomicStore),
                                                     b.AddressOf(lhs), rhs);
                                 return b.CallStmt(call);
                             });
@@ -266,7 +267,7 @@
                         if (is_ref_to_atomic_var(sem_rhs->UnwrapLoad())) {
                             ctx.Replace(assign->rhs, [=] {
                                 auto* rhs = ctx.CloneWithoutTransform(assign->rhs);
-                                return b.Call(sem::str(sem::BuiltinType::kAtomicLoad),
+                                return b.Call(builtin::str(builtin::Function::kAtomicLoad),
                                               b.AddressOf(rhs));
                             });
                             return;
@@ -278,7 +279,7 @@
                             if (is_ref_to_atomic_var(sem_init->UnwrapLoad())) {
                                 ctx.Replace(var->initializer, [=] {
                                     auto* rhs = ctx.CloneWithoutTransform(var->initializer);
-                                    return b.Call(sem::str(sem::BuiltinType::kAtomicLoad),
+                                    return b.Call(builtin::str(builtin::Function::kAtomicLoad),
                                                   b.AddressOf(rhs));
                                 });
                                 return;
@@ -293,11 +294,11 @@
 SpirvAtomic::SpirvAtomic() = default;
 SpirvAtomic::~SpirvAtomic() = default;
 
-SpirvAtomic::Stub::Stub(ProgramID pid, ast::NodeID nid, sem::BuiltinType b)
+SpirvAtomic::Stub::Stub(ProgramID pid, ast::NodeID nid, builtin::Function b)
     : Base(pid, nid, utils::Empty), builtin(b) {}
 SpirvAtomic::Stub::~Stub() = default;
 std::string SpirvAtomic::Stub::InternalName() const {
-    return "@internal(spirv-atomic " + std::string(sem::str(builtin)) + ")";
+    return "@internal(spirv-atomic " + std::string(builtin::str(builtin)) + ")";
 }
 
 const SpirvAtomic::Stub* SpirvAtomic::Stub::Clone(CloneContext* ctx) const {
diff --git a/src/tint/transform/spirv_atomic.h b/src/tint/transform/spirv_atomic.h
index 0f99dba..b524200 100644
--- a/src/tint/transform/spirv_atomic.h
+++ b/src/tint/transform/spirv_atomic.h
@@ -18,7 +18,7 @@
 #include <string>
 
 #include "src/tint/ast/internal_attribute.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
 #include "src/tint/transform/transform.h"
 
 // Forward declarations
@@ -46,7 +46,7 @@
         /// @param pid the identifier of the program that owns this node
         /// @param nid the unique node identifier
         /// @param builtin the atomic builtin this stub represents
-        Stub(ProgramID pid, ast::NodeID nid, sem::BuiltinType builtin);
+        Stub(ProgramID pid, ast::NodeID nid, builtin::Function builtin);
         /// Destructor
         ~Stub() override;
 
@@ -60,7 +60,7 @@
         const Stub* Clone(CloneContext* ctx) const override;
 
         /// The type of the intrinsic
-        const sem::BuiltinType builtin;
+        const builtin::Function builtin;
     };
 
     /// @copydoc Transform::Apply
diff --git a/src/tint/transform/spirv_atomic_test.cc b/src/tint/transform/spirv_atomic_test.cc
index 7bb9f2a..29976b5 100644
--- a/src/tint/transform/spirv_atomic_test.cc
+++ b/src/tint/transform/spirv_atomic_test.cc
@@ -36,14 +36,14 @@
 
         auto& b = parser.builder();
 
-        sem::BuiltinType two_params[] = {
-            sem::BuiltinType::kAtomicExchange, sem::BuiltinType::kAtomicAdd,
-            sem::BuiltinType::kAtomicSub,      sem::BuiltinType::kAtomicMin,
-            sem::BuiltinType::kAtomicMax,      sem::BuiltinType::kAtomicAnd,
-            sem::BuiltinType::kAtomicOr,       sem::BuiltinType::kAtomicXor,
+        builtin::Function two_params[] = {
+            builtin::Function::kAtomicExchange, builtin::Function::kAtomicAdd,
+            builtin::Function::kAtomicSub,      builtin::Function::kAtomicMin,
+            builtin::Function::kAtomicMax,      builtin::Function::kAtomicAnd,
+            builtin::Function::kAtomicOr,       builtin::Function::kAtomicXor,
         };
         for (auto& a : two_params) {
-            b.Func(std::string{"stub_"} + sem::str(a) + "_u32",
+            b.Func(std::string{"stub_"} + builtin::str(a) + "_u32",
                    utils::Vector{
                        b.Param("p0", b.ty.u32()),
                        b.Param("p1", b.ty.u32()),
@@ -55,7 +55,7 @@
                    utils::Vector{
                        b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(), a),
                    });
-            b.Func(std::string{"stub_"} + sem::str(a) + "_i32",
+            b.Func(std::string{"stub_"} + builtin::str(a) + "_i32",
                    utils::Vector{
                        b.Param("p0", b.ty.i32()),
                        b.Param("p1", b.ty.i32()),
@@ -79,7 +79,7 @@
                },
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
-                                                          sem::BuiltinType::kAtomicLoad),
+                                                          builtin::Function::kAtomicLoad),
                });
         b.Func("stub_atomicLoad_i32",
                utils::Vector{
@@ -91,7 +91,7 @@
                },
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
-                                                          sem::BuiltinType::kAtomicLoad),
+                                                          builtin::Function::kAtomicLoad),
                });
 
         b.Func("stub_atomicStore_u32",
@@ -102,7 +102,7 @@
                b.ty.void_(), utils::Empty,
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
-                                                          sem::BuiltinType::kAtomicStore),
+                                                          builtin::Function::kAtomicStore),
                });
         b.Func("stub_atomicStore_i32",
                utils::Vector{
@@ -112,7 +112,7 @@
                b.ty.void_(), utils::Empty,
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
-                                                          sem::BuiltinType::kAtomicStore),
+                                                          builtin::Function::kAtomicStore),
                });
 
         b.Func("stub_atomic_compare_exchange_weak_u32",
@@ -127,7 +127,7 @@
                },
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(
-                       b.ID(), b.AllocateNodeID(), sem::BuiltinType::kAtomicCompareExchangeWeak),
+                       b.ID(), b.AllocateNodeID(), builtin::Function::kAtomicCompareExchangeWeak),
                });
         b.Func("stub_atomic_compare_exchange_weak_i32",
                utils::Vector{b.Param("p0", b.ty.i32()), b.Param("p1", b.ty.i32()),
@@ -138,7 +138,7 @@
                },
                utils::Vector{
                    b.ASTNodes().Create<SpirvAtomic::Stub>(
-                       b.ID(), b.AllocateNodeID(), sem::BuiltinType::kAtomicCompareExchangeWeak),
+                       b.ID(), b.AllocateNodeID(), builtin::Function::kAtomicCompareExchangeWeak),
                });
 
         // Keep this pointer alive after Transform() returns
diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc
index 7a9cffc..bfd8c80 100644
--- a/src/tint/transform/std140.cc
+++ b/src/tint/transform/std140.cc
@@ -25,6 +25,7 @@
 #include "src/tint/sem/module.h"
 #include "src/tint/sem/struct.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/compiler_macros.h"
 #include "src/tint/utils/hashmap.h"
 #include "src/tint/utils/transform.h"
diff --git a/src/tint/transform/substitute_override.cc b/src/tint/transform/substitute_override.cc
index 2d6b995..04a9da0 100644
--- a/src/tint/transform/substitute_override.cc
+++ b/src/tint/transform/substitute_override.cc
@@ -17,10 +17,12 @@
 #include <functional>
 #include <utility>
 
+#include "src/tint/builtin/function.h"
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/builtin.h"
 #include "src/tint/sem/index_accessor_expression.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::SubstituteOverride);
 TINT_INSTANTIATE_TYPEINFO(tint::transform::SubstituteOverride::Config);
@@ -105,7 +107,7 @@
                 if (auto* access = sem->UnwrapMaterialize()->As<sem::IndexAccessorExpression>()) {
                     if (access->Object()->UnwrapMaterialize()->Type()->HoldsAbstract() &&
                         access->Index()->Stage() == sem::EvaluationStage::kOverride) {
-                        auto* obj = b.Call(sem::str(sem::BuiltinType::kTintMaterialize),
+                        auto* obj = b.Call(builtin::str(builtin::Function::kTintMaterialize),
                                            ctx.Clone(expr->object));
                         return b.IndexAccessor(obj, ctx.Clone(expr->index));
                     }
diff --git a/src/tint/transform/texture_1d_to_2d.cc b/src/tint/transform/texture_1d_to_2d.cc
index d1caaab..7c48db5 100644
--- a/src/tint/transform/texture_1d_to_2d.cc
+++ b/src/tint/transform/texture_1d_to_2d.cc
@@ -20,6 +20,7 @@
 #include "src/tint/sem/function.h"
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/type_expression.h"
+#include "src/tint/switch.h"
 #include "src/tint/type/texture_dimension.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::Texture1DTo2D);
@@ -137,7 +138,7 @@
                 return nullptr;
             }
 
-            if (builtin->Type() == sem::BuiltinType::kTextureDimensions) {
+            if (builtin->Type() == builtin::Function::kTextureDimensions) {
                 // If this textureDimensions() call is in a CallStatement, we can leave it
                 // unmodified since the return value will be dropped on the floor anyway.
                 if (call->Stmt()->Declaration()->Is<ast::CallStatement>()) {
diff --git a/src/tint/transform/unshadow.cc b/src/tint/transform/unshadow.cc
index 8f79544..9639cfc 100644
--- a/src/tint/transform/unshadow.cc
+++ b/src/tint/transform/unshadow.cc
@@ -23,6 +23,7 @@
 #include "src/tint/sem/function.h"
 #include "src/tint/sem/statement.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::Unshadow);
 
diff --git a/src/tint/transform/utils/get_insertion_point.cc b/src/tint/transform/utils/get_insertion_point.cc
index d10d134..bce7a7e 100644
--- a/src/tint/transform/utils/get_insertion_point.cc
+++ b/src/tint/transform/utils/get_insertion_point.cc
@@ -16,6 +16,7 @@
 #include "src/tint/debug.h"
 #include "src/tint/diagnostic/diagnostic.h"
 #include "src/tint/sem/for_loop_statement.h"
+#include "src/tint/switch.h"
 
 namespace tint::transform::utils {
 
diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc
index e07dcfe..d887198 100644
--- a/src/tint/transform/vertex_pulling.cc
+++ b/src/tint/transform/vertex_pulling.cc
@@ -23,6 +23,7 @@
 #include "src/tint/builtin/builtin_value.h"
 #include "src/tint/program_builder.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/compiler_macros.h"
 #include "src/tint/utils/map.h"
 #include "src/tint/utils/math.h"
diff --git a/src/tint/type/type.cc b/src/tint/type/type.cc
index 6163a9a..7ed62fa 100644
--- a/src/tint/type/type.cc
+++ b/src/tint/type/type.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/type/type.h"
 
+#include "src/tint/switch.h"
 #include "src/tint/type/abstract_float.h"
 #include "src/tint/type/abstract_int.h"
 #include "src/tint/type/array.h"
diff --git a/src/tint/utils/slice.h b/src/tint/utils/slice.h
index 719a53e..325c470 100644
--- a/src/tint/utils/slice.h
+++ b/src/tint/utils/slice.h
@@ -20,6 +20,7 @@
 
 #include "src/tint/castable.h"
 #include "src/tint/traits.h"
+#include "src/tint/utils/bitcast.h"
 
 namespace tint::utils {
 
diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc
index 98d9798..b66f9fd 100644
--- a/src/tint/writer/append_vector.cc
+++ b/src/tint/writer/append_vector.cc
@@ -21,6 +21,7 @@
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/switch.h"
 #include "src/tint/utils/transform.h"
 
 using namespace tint::number_suffixes;  // NOLINT
diff --git a/src/tint/writer/array_length_from_uniform_options.cc b/src/tint/writer/array_length_from_uniform_options.cc
index 7fd6e63..275867f 100644
--- a/src/tint/writer/array_length_from_uniform_options.cc
+++ b/src/tint/writer/array_length_from_uniform_options.cc
@@ -17,11 +17,15 @@
 namespace tint::writer {
 
 ArrayLengthFromUniformOptions::ArrayLengthFromUniformOptions() = default;
+
 ArrayLengthFromUniformOptions::~ArrayLengthFromUniformOptions() = default;
+
 ArrayLengthFromUniformOptions::ArrayLengthFromUniformOptions(const ArrayLengthFromUniformOptions&) =
     default;
+
 ArrayLengthFromUniformOptions& ArrayLengthFromUniformOptions::operator=(
     const ArrayLengthFromUniformOptions&) = default;
+
 ArrayLengthFromUniformOptions::ArrayLengthFromUniformOptions(ArrayLengthFromUniformOptions&&) =
     default;
 
diff --git a/src/tint/writer/array_length_from_uniform_options.h b/src/tint/writer/array_length_from_uniform_options.h
index 41d873e..b8b304a 100644
--- a/src/tint/writer/array_length_from_uniform_options.h
+++ b/src/tint/writer/array_length_from_uniform_options.h
@@ -17,7 +17,7 @@
 
 #include <unordered_map>
 
-#include "src/tint/sem/binding_point.h"
+#include "src/tint/writer/binding_point.h"
 
 namespace tint::writer {
 
@@ -38,10 +38,10 @@
 
     /// The binding point to use to generate a uniform buffer from which to read
     /// buffer sizes.
-    sem::BindingPoint ubo_binding;
+    BindingPoint ubo_binding;
     /// The mapping from storage buffer binding points to the index into the
     /// uniform buffer where the length of the buffer is stored.
-    std::unordered_map<sem::BindingPoint, uint32_t> bindpoint_to_size_index;
+    std::unordered_map<BindingPoint, uint32_t> bindpoint_to_size_index;
 
     /// Reflect the fields of this class so that it can be used by tint::ForeachField()
     TINT_REFLECT(ubo_binding, bindpoint_to_size_index);
diff --git a/src/tint/writer/generate_external_texture_bindings.h b/src/tint/writer/binding_point.h
similarity index 60%
rename from src/tint/writer/generate_external_texture_bindings.h
rename to src/tint/writer/binding_point.h
index 8d0aad9..796c54a 100644
--- a/src/tint/writer/generate_external_texture_bindings.h
+++ b/src/tint/writer/binding_point.h
@@ -1,4 +1,4 @@
-// Copyright 2022 The Tint Authors.
+// Copyright 2023 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_TINT_WRITER_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
-#define SRC_TINT_WRITER_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
+#ifndef SRC_TINT_WRITER_BINDING_POINT_H_
+#define SRC_TINT_WRITER_BINDING_POINT_H_
 
-#include "src/tint/transform/multiplanar_external_texture.h"
+#include "src/tint/sem/binding_point.h"
 
 namespace tint::writer {
 
-transform::MultiplanarExternalTexture::BindingsMap GenerateExternalTextureBindings(
-    const Program* program);
+/// BindingPoint is an alias to sem::BindingPoint
+using BindingPoint = sem::BindingPoint;
 
 }  // namespace tint::writer
 
-#endif  // SRC_TINT_WRITER_GENERATE_EXTERNAL_TEXTURE_BINDINGS_H_
+#endif  // SRC_TINT_WRITER_BINDING_POINT_H_
diff --git a/src/tint/writer/check_supported_extensions.cc b/src/tint/writer/check_supported_extensions.cc
index bde86a5..88ddcdd 100644
--- a/src/tint/writer/check_supported_extensions.cc
+++ b/src/tint/writer/check_supported_extensions.cc
@@ -33,13 +33,14 @@
     }
 
     for (auto* enable : module.Enables()) {
-        auto ext = enable->extension;
-        if (!set.Contains(ext)) {
-            diags.add_error(diag::System::Writer,
-                            std::string(writer_name) + " backend does not support extension '" +
-                                utils::ToString(ext) + "'",
-                            enable->source);
-            return false;
+        for (auto* ext : enable->extensions) {
+            if (!set.Contains(ext->name)) {
+                diags.add_error(diag::System::Writer,
+                                std::string(writer_name) + " backend does not support extension '" +
+                                    utils::ToString(ext->name) + "'",
+                                ext->source);
+                return false;
+            }
         }
     }
     return true;
diff --git a/src/tint/writer/external_texture_options.cc b/src/tint/writer/external_texture_options.cc
new file mode 100644
index 0000000..e5ea26f
--- /dev/null
+++ b/src/tint/writer/external_texture_options.cc
@@ -0,0 +1,29 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/writer/external_texture_options.h"
+
+namespace tint::writer {
+
+ExternalTextureOptions::ExternalTextureOptions() = default;
+
+ExternalTextureOptions::~ExternalTextureOptions() = default;
+
+ExternalTextureOptions::ExternalTextureOptions(const ExternalTextureOptions&) = default;
+
+ExternalTextureOptions& ExternalTextureOptions::operator=(const ExternalTextureOptions&) = default;
+
+ExternalTextureOptions::ExternalTextureOptions(ExternalTextureOptions&&) = default;
+
+}  // namespace tint::writer
diff --git a/src/tint/writer/external_texture_options.h b/src/tint/writer/external_texture_options.h
new file mode 100644
index 0000000..926eabd
--- /dev/null
+++ b/src/tint/writer/external_texture_options.h
@@ -0,0 +1,57 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_WRITER_EXTERNAL_TEXTURE_OPTIONS_H_
+#define SRC_TINT_WRITER_EXTERNAL_TEXTURE_OPTIONS_H_
+
+#include <unordered_map>
+
+#include "src/tint/sem/external_texture.h"
+
+namespace tint::writer {
+
+/// Options used to specify mappings of binding points for external textures.
+class ExternalTextureOptions {
+  public:
+    /// This struct identifies the binding groups and locations for new bindings to
+    /// use when transforming a texture_external instance.
+    using BindingPoints = sem::external_texture::BindingPoints;
+
+    /// BindingsMap is a map where the key is the binding location of a
+    /// texture_external and the value is a struct containing the desired
+    /// locations for new bindings expanded from the texture_external instance.
+    using BindingsMap = sem::external_texture::BindingsMap;
+
+    /// Constructor
+    ExternalTextureOptions();
+    /// Destructor
+    ~ExternalTextureOptions();
+    /// Copy constructor
+    ExternalTextureOptions(const ExternalTextureOptions&);
+    /// Copy assignment
+    /// @returns this ExternalTextureOptions
+    ExternalTextureOptions& operator=(const ExternalTextureOptions&);
+    /// Move constructor
+    ExternalTextureOptions(ExternalTextureOptions&&);
+
+    /// A map of new binding points to use.
+    BindingsMap bindings_map;
+
+    /// Reflect the fields of this class so that it can be used by tint::ForeachField()
+    TINT_REFLECT(bindings_map);
+};
+
+}  // namespace tint::writer
+
+#endif  // SRC_TINT_WRITER_EXTERNAL_TEXTURE_OPTIONS_H_
diff --git a/src/tint/writer/flatten_bindings.cc b/src/tint/writer/flatten_bindings.cc
index bedec75..3b5b2ad 100644
--- a/src/tint/writer/flatten_bindings.cc
+++ b/src/tint/writer/flatten_bindings.cc
@@ -19,11 +19,12 @@
 #include "src/tint/inspector/inspector.h"
 #include "src/tint/transform/binding_remapper.h"
 #include "src/tint/transform/manager.h"
+#include "src/tint/writer/binding_point.h"
 
 namespace tint::writer {
+
 std::optional<Program> FlattenBindings(const Program* program) {
     // TODO(crbug.com/tint/1101): Make this more robust for multiple entry points.
-    using BindingPoint = tint::transform::BindingPoint;
     tint::transform::BindingRemapper::BindingPoints binding_points;
     uint32_t next_buffer_idx = 0;
     uint32_t next_sampler_idx = 0;
@@ -76,4 +77,5 @@
 
     return {};
 }
+
 }  // namespace tint::writer
diff --git a/src/tint/writer/glsl/generator.h b/src/tint/writer/glsl/generator.h
index 2bb4b03..ef7b65b 100644
--- a/src/tint/writer/glsl/generator.h
+++ b/src/tint/writer/glsl/generator.h
@@ -25,6 +25,7 @@
 #include "src/tint/builtin/access.h"
 #include "src/tint/sem/binding_point.h"
 #include "src/tint/sem/sampler_texture_pair.h"
+#include "src/tint/writer/external_texture_options.h"
 #include "src/tint/writer/glsl/version.h"
 #include "src/tint/writer/text.h"
 
@@ -73,8 +74,8 @@
     /// Set to `true` to disable workgroup memory zero initialization
     bool disable_workgroup_init = false;
 
-    /// Set to 'true' to generates binding mappings for external textures
-    bool generate_external_texture_bindings = false;
+    /// Options used in the binding mappings for external textures
+    ExternalTextureOptions external_texture_options = {};
 
     /// The GLSL version to emit
     Version version;
@@ -83,7 +84,7 @@
     TINT_REFLECT(disable_robustness,
                  allow_collisions,
                  disable_workgroup_init,
-                 generate_external_texture_bindings,
+                 external_texture_options,
                  version);
 };
 
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 02c1bac..311005b 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -17,6 +17,7 @@
 #include <algorithm>
 #include <cmath>
 #include <iomanip>
+#include <limits>
 #include <set>
 #include <utility>
 #include <vector>
@@ -39,6 +40,7 @@
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/add_block_attribute.h"
 #include "src/tint/transform/add_empty_entry_point.h"
 #include "src/tint/transform/binding_remapper.h"
@@ -51,6 +53,7 @@
 #include "src/tint/transform/disable_uniformity_analysis.h"
 #include "src/tint/transform/expand_compound_assignment.h"
 #include "src/tint/transform/manager.h"
+#include "src/tint/transform/multiplanar_external_texture.h"
 #include "src/tint/transform/pad_structs.h"
 #include "src/tint/transform/preserve_padding.h"
 #include "src/tint/transform/promote_initializers_to_let.h"
@@ -79,12 +82,18 @@
 #include "src/tint/utils/string_stream.h"
 #include "src/tint/writer/append_vector.h"
 #include "src/tint/writer/float_to_string.h"
-#include "src/tint/writer/generate_external_texture_bindings.h"
 
 using namespace tint::number_suffixes;  // NOLINT
 
+namespace tint::writer::glsl {
 namespace {
 
+const char kTempNamePrefix[] = "tint_tmp";
+
+bool last_is_break(const ast::BlockStatement* stmts) {
+    return IsAnyOf<ast::BreakStatement>(stmts->Last());
+}
+
 bool IsRelational(tint::ast::BinaryOp op) {
     return op == tint::ast::BinaryOp::kEqual || op == tint::ast::BinaryOp::kNotEqual ||
            op == tint::ast::BinaryOp::kLessThan || op == tint::ast::BinaryOp::kGreaterThan ||
@@ -102,15 +111,15 @@
     }
 }
 
-}  // namespace
-
-namespace tint::writer::glsl {
-namespace {
-
-const char kTempNamePrefix[] = "tint_tmp";
-
-bool last_is_break(const ast::BlockStatement* stmts) {
-    return IsAnyOf<ast::BreakStatement>(stmts->Last());
+void PrintI32(utils::StringStream& out, int32_t value) {
+    // GLSL parses `-2147483648` as a unary minus and `2147483648` as separate tokens, and the
+    // latter doesn't fit into an (32-bit) `int`. Emit `(-2147483647 - 1)` instead, which ensures
+    // the expression type is `int`.
+    if (auto int_min = std::numeric_limits<int32_t>::min(); value == int_min) {
+        out << "(" << int_min + 1 << " - 1)";
+    } else {
+        out << value;
+    }
 }
 
 void PrintF32(utils::StringStream& out, float value) {
@@ -171,10 +180,10 @@
         manager.Add<transform::Robustness>();
     }
 
-    if (options.generate_external_texture_bindings) {
+    if (!options.external_texture_options.bindings_map.empty()) {
         // Note: it is more efficient for MultiplanarExternalTexture to come after Robustness
-        auto new_bindings_map = writer::GenerateExternalTextureBindings(in);
-        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(new_bindings_map);
+        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(
+            options.external_texture_options.bindings_map);
         manager.Add<transform::MultiplanarExternalTexture>();
     }
 
@@ -184,6 +193,7 @@
         polyfills.atanh = transform::BuiltinPolyfill::Level::kRangeCheck;
         polyfills.bgra8unorm = true;
         polyfills.bitshift_modulo = true;
+        polyfills.conv_f32_to_iu32 = true;
         polyfills.count_leading_zeros = true;
         polyfills.count_trailing_zeros = true;
         polyfills.extract_bits = transform::BuiltinPolyfill::Level::kClampParameters;
@@ -325,7 +335,7 @@
     }
 
     if (version_.IsES() && requires_default_precision_qualifier_) {
-        current_buffer_->Insert("precision mediump float;", helpers_insertion_point++, indent);
+        current_buffer_->Insert("precision highp float;", helpers_insertion_point++, indent);
     }
 
     if (!helpers_.lines.empty()) {
@@ -337,10 +347,10 @@
     return true;
 }
 
-bool GeneratorImpl::RecordExtension(const ast::Enable* ext) {
+bool GeneratorImpl::RecordExtension(const ast::Enable* enable) {
     // Deal with extension node here, recording it within the generator for later emition.
 
-    if (ext->extension == builtin::Extension::kF16) {
+    if (enable->HasExtension(builtin::Extension::kF16)) {
         requires_f16_extension_ = true;
     }
 
@@ -768,48 +778,49 @@
     if (builtin->IsTexture()) {
         return EmitTextureCall(out, call, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kCountOneBits) {
+    if (builtin->Type() == builtin::Function::kCountOneBits) {
         return EmitCountOneBitsCall(out, expr);
     }
-    if (builtin->Type() == sem::BuiltinType::kSelect) {
-        return EmitSelectCall(out, expr);
+    if (builtin->Type() == builtin::Function::kSelect) {
+        return EmitSelectCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kDot) {
+    if (builtin->Type() == builtin::Function::kDot) {
         return EmitDotCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kModf) {
+    if (builtin->Type() == builtin::Function::kModf) {
         return EmitModfCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kFrexp) {
+    if (builtin->Type() == builtin::Function::kFrexp) {
         return EmitFrexpCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kDegrees) {
+    if (builtin->Type() == builtin::Function::kDegrees) {
         return EmitDegreesCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kRadians) {
+    if (builtin->Type() == builtin::Function::kRadians) {
         return EmitRadiansCall(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kQuantizeToF16) {
+    if (builtin->Type() == builtin::Function::kQuantizeToF16) {
         return EmitQuantizeToF16Call(out, expr, builtin);
     }
-    if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+    if (builtin->Type() == builtin::Function::kArrayLength) {
         return EmitArrayLength(out, expr);
     }
-    if (builtin->Type() == sem::BuiltinType::kExtractBits) {
+    if (builtin->Type() == builtin::Function::kExtractBits) {
         return EmitExtractBits(out, expr);
     }
-    if (builtin->Type() == sem::BuiltinType::kInsertBits) {
+    if (builtin->Type() == builtin::Function::kInsertBits) {
         return EmitInsertBits(out, expr);
     }
-    if (builtin->Type() == sem::BuiltinType::kFma && version_.IsES()) {
+    if (builtin->Type() == builtin::Function::kFma && version_.IsES()) {
         return EmitEmulatedFMA(out, expr);
     }
-    if (builtin->Type() == sem::BuiltinType::kAbs &&
+    if (builtin->Type() == builtin::Function::kAbs &&
         TypeOf(expr->args[0])->UnwrapRef()->is_unsigned_integer_scalar_or_vector()) {
         // GLSL does not support abs() on unsigned arguments. However, it's a no-op.
         return EmitExpression(out, expr->args[0]);
     }
-    if ((builtin->Type() == sem::BuiltinType::kAny || builtin->Type() == sem::BuiltinType::kAll) &&
+    if ((builtin->Type() == builtin::Function::kAny ||
+         builtin->Type() == builtin::Function::kAll) &&
         TypeOf(expr->args[0])->UnwrapRef()->is_scalar()) {
         // GLSL does not support any() or all() on scalar arguments. It's a no-op.
         return EmitExpression(out, expr->args[0]);
@@ -911,7 +922,7 @@
     };
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAtomicLoad: {
+        case builtin::Function::kAtomicLoad: {
             // GLSL does not have an atomicLoad, so we emulate it with
             // atomicOr using 0 as the OR value
             out << "atomicOr";
@@ -927,7 +938,7 @@
             }
             return true;
         }
-        case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+        case builtin::Function::kAtomicCompareExchangeWeak: {
             if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
                 return false;
             }
@@ -978,27 +989,27 @@
             return true;
         }
 
-        case sem::BuiltinType::kAtomicAdd:
-        case sem::BuiltinType::kAtomicSub:
+        case builtin::Function::kAtomicAdd:
+        case builtin::Function::kAtomicSub:
             return call("atomicAdd");
 
-        case sem::BuiltinType::kAtomicMax:
+        case builtin::Function::kAtomicMax:
             return call("atomicMax");
 
-        case sem::BuiltinType::kAtomicMin:
+        case builtin::Function::kAtomicMin:
             return call("atomicMin");
 
-        case sem::BuiltinType::kAtomicAnd:
+        case builtin::Function::kAtomicAnd:
             return call("atomicAnd");
 
-        case sem::BuiltinType::kAtomicOr:
+        case builtin::Function::kAtomicOr:
             return call("atomicOr");
 
-        case sem::BuiltinType::kAtomicXor:
+        case builtin::Function::kAtomicXor:
             return call("atomicXor");
 
-        case sem::BuiltinType::kAtomicExchange:
-        case sem::BuiltinType::kAtomicStore:
+        case builtin::Function::kAtomicExchange:
+        case builtin::Function::kAtomicStore:
             // GLSL does not have an atomicStore, so we emulate it with
             // atomicExchange.
             return call("atomicExchange");
@@ -1092,28 +1103,39 @@
     return true;
 }
 
-bool GeneratorImpl::EmitSelectCall(utils::StringStream& out, const ast::CallExpression* expr) {
+bool GeneratorImpl::EmitSelectCall(utils::StringStream& out,
+                                   const ast::CallExpression* expr,
+                                   const sem::Builtin* builtin) {
+    // GLSL does not support ternary expressions with a bool vector conditional,
+    // so polyfill with a helper.
+    if (auto* vec = builtin->Parameters()[2]->Type()->As<type::Vector>()) {
+        return CallBuiltinHelper(
+            out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
+                auto l = line(b);
+                l << "  return ";
+                if (!EmitType(l, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
+                              builtin::Access::kUndefined, "")) {
+                    return false;
+                }
+                {
+                    ScopedParen sp(l);
+                    for (uint32_t i = 0; i < vec->Width(); i++) {
+                        if (i > 0) {
+                            l << ", ";
+                        }
+                        l << params[2] << "[" << i << "] ? " << params[1] << "[" << i
+                          << "] : " << params[0] << "[" << i << "]";
+                    }
+                }
+                l << ";";
+                return true;
+            });
+    }
+
     auto* expr_false = expr->args[0];
     auto* expr_true = expr->args[1];
     auto* expr_cond = expr->args[2];
-    // GLSL does not support ternary expressions with a bool vector conditional,
-    // but it does support mix() with same.
-    if (TypeOf(expr_cond)->UnwrapRef()->is_bool_vector()) {
-        out << "mix(";
-        if (!EmitExpression(out, expr_false)) {
-            return false;
-        }
-        out << ", ";
-        if (!EmitExpression(out, expr_true)) {
-            return false;
-        }
-        out << ", ";
-        if (!EmitExpression(out, expr_cond)) {
-            return false;
-        }
-        out << ")";
-        return true;
-    }
+
     ScopedParen paren(out);
     if (!EmitExpression(out, expr_cond)) {
         return false;
@@ -1320,13 +1342,13 @@
 bool GeneratorImpl::EmitBarrierCall(utils::StringStream& out, const sem::Builtin* builtin) {
     // TODO(crbug.com/tint/661): Combine sequential barriers to a single
     // instruction.
-    if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+    if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
         out << "barrier()";
-    } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+    } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
         out << "{ barrier(); memoryBarrierBuffer(); }";
     } else {
         TINT_UNREACHABLE(Writer, diagnostics_)
-            << "unexpected barrier builtin type " << sem::str(builtin->Type());
+            << "unexpected barrier builtin type " << builtin::str(builtin->Type());
         return false;
     }
     return true;
@@ -1396,7 +1418,7 @@
     };
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureDimensions: {
+        case builtin::Function::kTextureDimensions: {
             // textureDimensions() returns an unsigned scalar / vector in WGSL.
             // textureSize() / imageSize() returns a signed scalar / vector in GLSL.
             // Cast.
@@ -1435,7 +1457,7 @@
             }
             return true;
         }
-        case sem::BuiltinType::kTextureNumLayers: {
+        case builtin::Function::kTextureNumLayers: {
             // textureNumLayers() returns an unsigned scalar in WGSL.
             // textureSize() / imageSize() returns a signed scalar / vector in GLSL.
             // Cast.
@@ -1469,7 +1491,7 @@
             out << ").z";
             return true;
         }
-        case sem::BuiltinType::kTextureNumLevels: {
+        case builtin::Function::kTextureNumLevels: {
             // textureNumLevels() returns an unsigned scalar in WGSL.
             // textureQueryLevels() returns a signed scalar in GLSL.
             // Cast.
@@ -1483,7 +1505,7 @@
             out << ")";
             return true;
         }
-        case sem::BuiltinType::kTextureNumSamples: {
+        case builtin::Function::kTextureNumSamples: {
             // textureNumSamples() returns an unsigned scalar in WGSL.
             // textureSamples() returns a signed scalar in GLSL.
             // Cast.
@@ -1506,36 +1528,36 @@
     bool is_depth = texture_type->Is<type::DepthTexture>();
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureSample:
-        case sem::BuiltinType::kTextureSampleBias:
+        case builtin::Function::kTextureSample:
+        case builtin::Function::kTextureSampleBias:
             out << "texture";
             if (is_depth) {
                 glsl_ret_width = 1u;
             }
             break;
-        case sem::BuiltinType::kTextureSampleLevel:
+        case builtin::Function::kTextureSampleLevel:
             out << "textureLod";
             if (is_depth) {
                 glsl_ret_width = 1u;
             }
             break;
-        case sem::BuiltinType::kTextureGather:
-        case sem::BuiltinType::kTextureGatherCompare:
+        case builtin::Function::kTextureGather:
+        case builtin::Function::kTextureGatherCompare:
             out << "textureGather";
             append_depth_ref_to_coords = false;
             break;
-        case sem::BuiltinType::kTextureSampleGrad:
+        case builtin::Function::kTextureSampleGrad:
             out << "textureGrad";
             break;
-        case sem::BuiltinType::kTextureSampleCompare:
-        case sem::BuiltinType::kTextureSampleCompareLevel:
+        case builtin::Function::kTextureSampleCompare:
+        case builtin::Function::kTextureSampleCompareLevel:
             out << "texture";
             glsl_ret_width = 1;
             break;
-        case sem::BuiltinType::kTextureLoad:
+        case builtin::Function::kTextureLoad:
             out << "texelFetch";
             break;
-        case sem::BuiltinType::kTextureStore:
+        case builtin::Function::kTextureStore:
             out << "imageStore";
             break;
         default:
@@ -1614,7 +1636,7 @@
     }
 
     // GLSL's textureGather always requires a refZ parameter.
-    if (is_depth && builtin->Type() == sem::BuiltinType::kTextureGather) {
+    if (is_depth && builtin->Type() == builtin::Function::kTextureGather) {
         out << ", 0.0";
     }
 
@@ -1625,7 +1647,7 @@
             if (!EmitExpression(out, e)) {
                 return false;
             }
-        } else if (builtin->Type() == sem::BuiltinType::kTextureSample) {
+        } else if (builtin->Type() == builtin::Function::kTextureSample) {
             out << ", 0.0f";
         }
     }
@@ -1669,114 +1691,114 @@
 
 std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAbs:
-        case sem::BuiltinType::kAcos:
-        case sem::BuiltinType::kAcosh:
-        case sem::BuiltinType::kAll:
-        case sem::BuiltinType::kAny:
-        case sem::BuiltinType::kAsin:
-        case sem::BuiltinType::kAsinh:
-        case sem::BuiltinType::kAtan:
-        case sem::BuiltinType::kAtanh:
-        case sem::BuiltinType::kCeil:
-        case sem::BuiltinType::kClamp:
-        case sem::BuiltinType::kCos:
-        case sem::BuiltinType::kCosh:
-        case sem::BuiltinType::kCross:
-        case sem::BuiltinType::kDeterminant:
-        case sem::BuiltinType::kDistance:
-        case sem::BuiltinType::kDot:
-        case sem::BuiltinType::kExp:
-        case sem::BuiltinType::kExp2:
-        case sem::BuiltinType::kFloor:
-        case sem::BuiltinType::kFrexp:
-        case sem::BuiltinType::kLdexp:
-        case sem::BuiltinType::kLength:
-        case sem::BuiltinType::kLog:
-        case sem::BuiltinType::kLog2:
-        case sem::BuiltinType::kMax:
-        case sem::BuiltinType::kMin:
-        case sem::BuiltinType::kModf:
-        case sem::BuiltinType::kNormalize:
-        case sem::BuiltinType::kPow:
-        case sem::BuiltinType::kReflect:
-        case sem::BuiltinType::kRefract:
-        case sem::BuiltinType::kRound:
-        case sem::BuiltinType::kSign:
-        case sem::BuiltinType::kSin:
-        case sem::BuiltinType::kSinh:
-        case sem::BuiltinType::kSqrt:
-        case sem::BuiltinType::kStep:
-        case sem::BuiltinType::kTan:
-        case sem::BuiltinType::kTanh:
-        case sem::BuiltinType::kTranspose:
-        case sem::BuiltinType::kTrunc:
+        case builtin::Function::kAbs:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAcosh:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAsinh:
+        case builtin::Function::kAtan:
+        case builtin::Function::kAtanh:
+        case builtin::Function::kCeil:
+        case builtin::Function::kClamp:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kCross:
+        case builtin::Function::kDeterminant:
+        case builtin::Function::kDistance:
+        case builtin::Function::kDot:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFrexp:
+        case builtin::Function::kLdexp:
+        case builtin::Function::kLength:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kMax:
+        case builtin::Function::kMin:
+        case builtin::Function::kModf:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kRefract:
+        case builtin::Function::kRound:
+        case builtin::Function::kSign:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kStep:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTranspose:
+        case builtin::Function::kTrunc:
             return builtin->str();
-        case sem::BuiltinType::kAtan2:
+        case builtin::Function::kAtan2:
             return "atan";
-        case sem::BuiltinType::kCountOneBits:
+        case builtin::Function::kCountOneBits:
             return "bitCount";
-        case sem::BuiltinType::kDpdx:
+        case builtin::Function::kDpdx:
             return "dFdx";
-        case sem::BuiltinType::kDpdxCoarse:
+        case builtin::Function::kDpdxCoarse:
             if (version_.IsES()) {
                 return "dFdx";
             }
             return "dFdxCoarse";
-        case sem::BuiltinType::kDpdxFine:
+        case builtin::Function::kDpdxFine:
             if (version_.IsES()) {
                 return "dFdx";
             }
             return "dFdxFine";
-        case sem::BuiltinType::kDpdy:
+        case builtin::Function::kDpdy:
             return "dFdy";
-        case sem::BuiltinType::kDpdyCoarse:
+        case builtin::Function::kDpdyCoarse:
             if (version_.IsES()) {
                 return "dFdy";
             }
             return "dFdyCoarse";
-        case sem::BuiltinType::kDpdyFine:
+        case builtin::Function::kDpdyFine:
             if (version_.IsES()) {
                 return "dFdy";
             }
             return "dFdyFine";
-        case sem::BuiltinType::kFaceForward:
+        case builtin::Function::kFaceForward:
             return "faceforward";
-        case sem::BuiltinType::kFract:
+        case builtin::Function::kFract:
             return "fract";
-        case sem::BuiltinType::kFma:
+        case builtin::Function::kFma:
             return "fma";
-        case sem::BuiltinType::kFwidth:
-        case sem::BuiltinType::kFwidthCoarse:
-        case sem::BuiltinType::kFwidthFine:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
             return "fwidth";
-        case sem::BuiltinType::kInverseSqrt:
+        case builtin::Function::kInverseSqrt:
             return "inversesqrt";
-        case sem::BuiltinType::kMix:
+        case builtin::Function::kMix:
             return "mix";
-        case sem::BuiltinType::kPack2X16Float:
+        case builtin::Function::kPack2X16Float:
             return "packHalf2x16";
-        case sem::BuiltinType::kPack2X16Snorm:
+        case builtin::Function::kPack2X16Snorm:
             return "packSnorm2x16";
-        case sem::BuiltinType::kPack2X16Unorm:
+        case builtin::Function::kPack2X16Unorm:
             return "packUnorm2x16";
-        case sem::BuiltinType::kPack4X8Snorm:
+        case builtin::Function::kPack4X8Snorm:
             return "packSnorm4x8";
-        case sem::BuiltinType::kPack4X8Unorm:
+        case builtin::Function::kPack4X8Unorm:
             return "packUnorm4x8";
-        case sem::BuiltinType::kReverseBits:
+        case builtin::Function::kReverseBits:
             return "bitfieldReverse";
-        case sem::BuiltinType::kSmoothstep:
+        case builtin::Function::kSmoothstep:
             return "smoothstep";
-        case sem::BuiltinType::kUnpack2X16Float:
+        case builtin::Function::kUnpack2X16Float:
             return "unpackHalf2x16";
-        case sem::BuiltinType::kUnpack2X16Snorm:
+        case builtin::Function::kUnpack2X16Snorm:
             return "unpackSnorm2x16";
-        case sem::BuiltinType::kUnpack2X16Unorm:
+        case builtin::Function::kUnpack2X16Unorm:
             return "unpackUnorm2x16";
-        case sem::BuiltinType::kUnpack4X8Snorm:
+        case builtin::Function::kUnpack4X8Snorm:
             return "unpackSnorm4x8";
-        case sem::BuiltinType::kUnpack4X8Unorm:
+        case builtin::Function::kUnpack4X8Unorm:
             return "unpackUnorm4x8";
         default:
             diagnostics_.add_error(diag::System::Writer,
@@ -2367,7 +2389,7 @@
             return true;
         },
         [&](const type::I32*) {
-            out << constant->ValueAs<AInt>();
+            PrintI32(out, constant->ValueAs<i32>());
             return true;
         },
         [&](const type::U32*) {
@@ -2382,8 +2404,8 @@
 
             ScopedParen sp(out);
 
-            if (constant->AllEqual()) {
-                return EmitConstant(out, constant->Index(0));
+            if (auto* splat = constant->As<constant::Splat>()) {
+                return EmitConstant(out, splat->el);
             }
 
             for (size_t i = 0; i < v->Width(); i++) {
@@ -2483,12 +2505,20 @@
             }
             return true;
         },
-        [&](const ast::IntLiteralExpression* l) {
-            out << l->value;
-            if (l->suffix == ast::IntLiteralExpression::Suffix::kU) {
-                out << "u";
+        [&](const ast::IntLiteralExpression* i) {
+            switch (i->suffix) {
+                case ast::IntLiteralExpression::Suffix::kNone:
+                case ast::IntLiteralExpression::Suffix::kI: {
+                    PrintI32(out, static_cast<int32_t>(i->value));
+                    return true;
+                }
+                case ast::IntLiteralExpression::Suffix::kU: {
+                    out << i->value << "u";
+                    return true;
+                }
             }
-            return true;
+            diagnostics_.add_error(diag::System::Writer, "unknown integer literal suffix type");
+            return false;
         },
         [&](Default) {
             diagnostics_.add_error(diag::System::Writer, "unknown literal type");
@@ -3209,7 +3239,7 @@
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
-        auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+        auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
         std::vector<std::string> parameter_names;
         {
             auto decl = line(&b);
diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h
index d954921..96042c1 100644
--- a/src/tint/writer/glsl/generator_impl.h
+++ b/src/tint/writer/glsl/generator_impl.h
@@ -234,8 +234,11 @@
     /// Handles generating a call to the `countOneBits()` builtin
     /// @param out the output of the expression stream
     /// @param expr the call expression
+    /// @param builtin the semantic information for the builtin
     /// @returns true if the call expression is emitted
-    bool EmitSelectCall(utils::StringStream& out, const ast::CallExpression* expr);
+    bool EmitSelectCall(utils::StringStream& out,
+                        const ast::CallExpression* expr,
+                        const sem::Builtin* builtin);
     /// Handles generating a call to the `dot()` builtin
     /// @param out the output of the expression stream
     /// @param expr the call expression
diff --git a/src/tint/writer/glsl/generator_impl_builtin_test.cc b/src/tint/writer/glsl/generator_impl_builtin_test.cc
index d281cdb..27cd717 100644
--- a/src/tint/writer/glsl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/glsl/generator_impl_builtin_test.cc
@@ -26,8 +26,6 @@
 namespace tint::writer::glsl {
 namespace {
 
-using BuiltinType = sem::BuiltinType;
-
 using GlslGeneratorImplTest_Builtin = TestHelper;
 
 enum class CallParamType {
@@ -38,7 +36,7 @@
 };
 
 struct BuiltinData {
-    BuiltinType builtin;
+    builtin::Function builtin;
     CallParamType type;
     const char* glsl_name;
 };
@@ -62,86 +60,86 @@
     return out;
 }
 
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
                                         CallParamType type,
                                         ProgramBuilder* builder) {
     std::string name;
     utils::StringStream str;
     str << name << builtin;
     switch (builtin) {
-        case BuiltinType::kAcos:
-        case BuiltinType::kAsin:
-        case BuiltinType::kAtan:
-        case BuiltinType::kCeil:
-        case BuiltinType::kCos:
-        case BuiltinType::kCosh:
-        case BuiltinType::kDpdx:
-        case BuiltinType::kDpdxCoarse:
-        case BuiltinType::kDpdxFine:
-        case BuiltinType::kDpdy:
-        case BuiltinType::kDpdyCoarse:
-        case BuiltinType::kDpdyFine:
-        case BuiltinType::kExp:
-        case BuiltinType::kExp2:
-        case BuiltinType::kFloor:
-        case BuiltinType::kFract:
-        case BuiltinType::kFwidth:
-        case BuiltinType::kFwidthCoarse:
-        case BuiltinType::kFwidthFine:
-        case BuiltinType::kInverseSqrt:
-        case BuiltinType::kLength:
-        case BuiltinType::kLog:
-        case BuiltinType::kLog2:
-        case BuiltinType::kNormalize:
-        case BuiltinType::kRound:
-        case BuiltinType::kSin:
-        case BuiltinType::kSinh:
-        case BuiltinType::kSqrt:
-        case BuiltinType::kTan:
-        case BuiltinType::kTanh:
-        case BuiltinType::kTrunc:
-        case BuiltinType::kSign:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAtan:
+        case builtin::Function::kCeil:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kDpdx:
+        case builtin::Function::kDpdxCoarse:
+        case builtin::Function::kDpdxFine:
+        case builtin::Function::kDpdy:
+        case builtin::Function::kDpdyCoarse:
+        case builtin::Function::kDpdyFine:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFract:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
+        case builtin::Function::kInverseSqrt:
+        case builtin::Function::kLength:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kRound:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTrunc:
+        case builtin::Function::kSign:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2");
             } else {
                 return builder->Call(str.str(), "f2");
             }
-        case BuiltinType::kLdexp:
+        case builtin::Function::kLdexp:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "i2");
             } else {
                 return builder->Call(str.str(), "f2", "i2");
             }
-        case BuiltinType::kAtan2:
-        case BuiltinType::kDot:
-        case BuiltinType::kDistance:
-        case BuiltinType::kPow:
-        case BuiltinType::kReflect:
-        case BuiltinType::kStep:
+        case builtin::Function::kAtan2:
+        case builtin::Function::kDot:
+        case builtin::Function::kDistance:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kStep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2");
             }
-        case BuiltinType::kCross:
+        case builtin::Function::kCross:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h3", "h3");
             } else {
                 return builder->Call(str.str(), "f3", "f3");
             }
-        case BuiltinType::kFma:
-        case BuiltinType::kMix:
-        case BuiltinType::kFaceForward:
-        case BuiltinType::kSmoothstep:
+        case builtin::Function::kFma:
+        case builtin::Function::kMix:
+        case builtin::Function::kFaceForward:
+        case builtin::Function::kSmoothstep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             }
-        case BuiltinType::kAll:
-        case BuiltinType::kAny:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
             return builder->Call(str.str(), "b2");
-        case BuiltinType::kAbs:
+        case builtin::Function::kAbs:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2");
             } else if (type == CallParamType::kF16) {
@@ -149,11 +147,11 @@
             } else {
                 return builder->Call(str.str(), "u2");
             }
-        case BuiltinType::kCountOneBits:
-        case BuiltinType::kReverseBits:
+        case builtin::Function::kCountOneBits:
+        case builtin::Function::kReverseBits:
             return builder->Call(str.str(), "u2");
-        case BuiltinType::kMax:
-        case BuiltinType::kMin:
+        case builtin::Function::kMax:
+        case builtin::Function::kMin:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -161,7 +159,7 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2");
             }
-        case BuiltinType::kClamp:
+        case builtin::Function::kClamp:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -169,19 +167,19 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2", "u2");
             }
-        case BuiltinType::kSelect:
+        case builtin::Function::kSelect:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "b2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "b2");
             }
-        case BuiltinType::kDeterminant:
+        case builtin::Function::kDeterminant:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm2x2");
             } else {
                 return builder->Call(str.str(), "m2x2");
             }
-        case BuiltinType::kTranspose:
+        case builtin::Function::kTranspose:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm3x2");
             } else {
@@ -235,110 +233,111 @@
 INSTANTIATE_TEST_SUITE_P(
     GlslGeneratorImplTest_Builtin,
     GlslBuiltinTest,
-    testing::Values(/* Logical built-in */
-                    BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
-                    BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
-                    /* Float built-in */
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "abs"},
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "abs"},
-                    BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
-                    BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
-                    BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
-                    BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
-                    BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
-                    BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
-                    BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan"},
-                    BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan"},
-                    BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
-                    BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
-                    BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
-                    BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
-                    BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
-                    BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
-                    BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
-                    BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
-                    BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
-                    BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
-                    BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
-                    BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
-                    BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
-                    BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
-                    BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
-                    BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
-                    BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
-                    BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
-                    BuiltinData{BuiltinType::kFma, CallParamType::kF32, "fma"},
-                    BuiltinData{BuiltinType::kFma, CallParamType::kF16, "fma"},
-                    BuiltinData{BuiltinType::kFract, CallParamType::kF32, "fract"},
-                    BuiltinData{BuiltinType::kFract, CallParamType::kF16, "fract"},
-                    BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
-                    BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
-                    BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
-                    BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
-                    BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
-                    BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
-                    BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
-                    BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
-                    BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
-                    BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kF32, "max"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kF16, "max"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kF32, "min"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kF16, "min"},
-                    BuiltinData{BuiltinType::kMix, CallParamType::kF32, "mix"},
-                    BuiltinData{BuiltinType::kMix, CallParamType::kF16, "mix"},
-                    BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
-                    BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
-                    BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
-                    BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
-                    BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
-                    BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
-                    BuiltinData{BuiltinType::kSign, CallParamType::kF32, "sign"},
-                    BuiltinData{BuiltinType::kSign, CallParamType::kF16, "sign"},
-                    BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
-                    BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
-                    BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
-                    BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
-                    BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
-                    BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
-                    BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
-                    BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
-                    BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
-                    BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
-                    BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
-                    BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
-                    BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
-                    BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
-                    BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
-                    BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
-                    /* Integer built-in */
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
-                    BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "bitCount"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
-                    BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "bitfieldReverse"},
-                    BuiltinData{BuiltinType::kRound, CallParamType::kU32, "round"},
-                    /* Matrix built-in */
-                    BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
-                    BuiltinData{BuiltinType::kDeterminant, CallParamType::kF16, "determinant"},
-                    BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
-                    BuiltinData{BuiltinType::kTranspose, CallParamType::kF16, "transpose"},
-                    /* Vector built-in */
-                    BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
-                    BuiltinData{BuiltinType::kDot, CallParamType::kF16, "dot"},
-                    /* Derivate built-in */
-                    BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "dFdx"},
-                    BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "dFdx"},
-                    BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "dFdx"},
-                    BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "dFdy"},
-                    BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "dFdy"},
-                    BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "dFdy"},
-                    BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
-                    BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
-                    BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"}));
+    testing::
+        Values(/* Logical built-in */
+               BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+               BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
+               /* Float built-in */
+               BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "abs"},
+               BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "abs"},
+               BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+               BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+               BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+               BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+               BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+               BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+               BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan"},
+               BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan"},
+               BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+               BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+               BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+               BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+               BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+               BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+               BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+               BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+               BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+               BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+               BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+               BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+               BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+               BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+               BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+               BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+               BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32, "faceforward"},
+               BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16, "faceforward"},
+               BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+               BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+               BuiltinData{builtin::Function::kFma, CallParamType::kF32, "fma"},
+               BuiltinData{builtin::Function::kFma, CallParamType::kF16, "fma"},
+               BuiltinData{builtin::Function::kFract, CallParamType::kF32, "fract"},
+               BuiltinData{builtin::Function::kFract, CallParamType::kF16, "fract"},
+               BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
+               BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
+               BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+               BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+               BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+               BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+               BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+               BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+               BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+               BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+               BuiltinData{builtin::Function::kMax, CallParamType::kF32, "max"},
+               BuiltinData{builtin::Function::kMax, CallParamType::kF16, "max"},
+               BuiltinData{builtin::Function::kMin, CallParamType::kF32, "min"},
+               BuiltinData{builtin::Function::kMin, CallParamType::kF16, "min"},
+               BuiltinData{builtin::Function::kMix, CallParamType::kF32, "mix"},
+               BuiltinData{builtin::Function::kMix, CallParamType::kF16, "mix"},
+               BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+               BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+               BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+               BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+               BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+               BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+               BuiltinData{builtin::Function::kSign, CallParamType::kF32, "sign"},
+               BuiltinData{builtin::Function::kSign, CallParamType::kF16, "sign"},
+               BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+               BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+               BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+               BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+               BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+               BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+               BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+               BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+               BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+               BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+               BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+               BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+               BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+               BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+               BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+               BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
+               /* Integer built-in */
+               BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+               BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+               BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "bitCount"},
+               BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+               BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+               BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32, "bitfieldReverse"},
+               BuiltinData{builtin::Function::kRound, CallParamType::kU32, "round"},
+               /* Matrix built-in */
+               BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32, "determinant"},
+               BuiltinData{builtin::Function::kDeterminant, CallParamType::kF16, "determinant"},
+               BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
+               BuiltinData{builtin::Function::kTranspose, CallParamType::kF16, "transpose"},
+               /* Vector built-in */
+               BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
+               BuiltinData{builtin::Function::kDot, CallParamType::kF16, "dot"},
+               /* Derivate built-in */
+               BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "dFdx"},
+               BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "dFdx"},
+               BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "dFdx"},
+               BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "dFdy"},
+               BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "dFdy"},
+               BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "dFdy"},
+               BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+               BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+               BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
 
 TEST_F(GlslGeneratorImplTest_Builtin, Builtin_Call) {
     auto* call = Call("dot", "param1", "param2");
@@ -379,7 +378,7 @@
     gen.increment_indent();
     utils::StringStream out;
     ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
-    EXPECT_EQ(out.str(), "mix(a, b, bvec2(true, false))");
+    EXPECT_EQ(out.str(), "tint_select(a, b, bvec2(true, false))");
 }
 
 TEST_F(GlslGeneratorImplTest_Builtin, FMA_f32) {
diff --git a/src/tint/writer/glsl/generator_impl_builtin_texture_test.cc b/src/tint/writer/glsl/generator_impl_builtin_texture_test.cc
index bbb3848..040adfe 100644
--- a/src/tint/writer/glsl/generator_impl_builtin_texture_test.cc
+++ b/src/tint/writer/glsl/generator_impl_builtin_texture_test.cc
@@ -98,6 +98,8 @@
             return R"(textureGather(Texture_Sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), 5.0f))";
         case ValidTextureOverload::kNumLayers2dArray:
         case ValidTextureOverload::kNumLayersDepth2dArray:
+        case ValidTextureOverload::kNumLayersCubeArray:
+        case ValidTextureOverload::kNumLayersDepthCubeArray:
             return {"textureSize"};
         case ValidTextureOverload::kNumLayersStorageWO2dArray:
             return {"imageSize"};
diff --git a/src/tint/writer/glsl/generator_impl_function_test.cc b/src/tint/writer/glsl/generator_impl_function_test.cc
index 05d1460..bc085b9 100644
--- a/src/tint/writer/glsl/generator_impl_function_test.cc
+++ b/src/tint/writer/glsl/generator_impl_function_test.cc
@@ -98,7 +98,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 void func() {
   return;
@@ -145,7 +145,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 layout(location = 0) in float foo_1;
 layout(location = 1) out float value;
@@ -186,7 +186,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 float frag_main(vec4 coord) {
   return coord.x;
@@ -239,7 +239,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 layout(location = 1) out float col1_1;
 layout(location = 2) out float col2_1;
@@ -378,7 +378,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct UBO {
   vec4 coord;
@@ -419,7 +419,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Uniforms {
   vec4 coord;
@@ -460,7 +460,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   int a;
@@ -508,7 +508,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(),
               R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   int a;
@@ -553,7 +553,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   int a;
@@ -598,7 +598,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   int a;
@@ -645,7 +645,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct S {
   float x;
@@ -692,7 +692,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(),
               R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct S {
   float x;
@@ -728,7 +728,7 @@
 
     ASSERT_TRUE(gen.Generate()) << gen.error();
     EXPECT_EQ(gen.result(), R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 void tint_symbol() {
 }
diff --git a/src/tint/writer/glsl/generator_impl_member_accessor_test.cc b/src/tint/writer/glsl/generator_impl_member_accessor_test.cc
index 2eb1b8e..6d0d58e 100644
--- a/src/tint/writer/glsl/generator_impl_member_accessor_test.cc
+++ b/src/tint/writer/glsl/generator_impl_member_accessor_test.cc
@@ -281,7 +281,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   int a;
@@ -334,7 +334,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   float z;
@@ -382,7 +382,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   float z;
@@ -430,7 +430,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   float z;
@@ -477,7 +477,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Data {
   float z;
@@ -530,7 +530,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   vec3 a;
@@ -591,7 +591,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   vec3 a;
@@ -653,7 +653,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   vec3 a;
@@ -714,7 +714,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   vec3 a;
@@ -774,7 +774,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   vec3 a;
@@ -835,7 +835,7 @@
     ASSERT_TRUE(gen.Generate()) << gen.error();
     auto* expected =
         R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct Inner {
   ivec3 a;
diff --git a/src/tint/writer/glsl/generator_impl_sanitizer_test.cc b/src/tint/writer/glsl/generator_impl_sanitizer_test.cc
index e85d050..5ed2be7 100644
--- a/src/tint/writer/glsl/generator_impl_sanitizer_test.cc
+++ b/src/tint/writer/glsl/generator_impl_sanitizer_test.cc
@@ -43,7 +43,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float a[];
@@ -83,7 +83,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float z;
@@ -127,7 +127,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float a[];
@@ -164,7 +164,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 void tint_symbol() {
   int idx = 3;
@@ -206,7 +206,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 struct S {
   int a;
@@ -252,7 +252,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 void tint_symbol() {
   int v = 0;
@@ -301,7 +301,7 @@
 
     auto got = gen.result();
     auto* expect = R"(#version 310 es
-precision mediump float;
+precision highp float;
 
 void tint_symbol() {
   mat4 a[4] = mat4[4](mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
diff --git a/src/tint/writer/glsl/generator_impl_switch_test.cc b/src/tint/writer/glsl/generator_impl_switch_test.cc
index b9ff49d..8e2f739 100644
--- a/src/tint/writer/glsl/generator_impl_switch_test.cc
+++ b/src/tint/writer/glsl/generator_impl_switch_test.cc
@@ -31,7 +31,7 @@
     auto* case_stmt = create<ast::CaseStatement>(utils::Vector{CaseSelector(5_i)}, case_body);
 
     auto* cond = Expr("cond");
-    auto* s = create<ast::SwitchStatement>(cond, utils::Vector{case_stmt, def});
+    auto* s = create<ast::SwitchStatement>(cond, utils::Vector{case_stmt, def}, utils::Empty);
     WrapInFunction(s);
 
     GeneratorImpl& gen = Build();
@@ -58,7 +58,7 @@
                                            def_body);
 
     auto* cond = Expr("cond");
-    auto* s = create<ast::SwitchStatement>(cond, utils::Vector{def});
+    auto* s = create<ast::SwitchStatement>(cond, utils::Vector{def}, utils::Empty);
     WrapInFunction(s);
 
     GeneratorImpl& gen = Build();
diff --git a/src/tint/writer/glsl/generator_impl_unary_op_test.cc b/src/tint/writer/glsl/generator_impl_unary_op_test.cc
index b7c5fd1..27e9d2c 100644
--- a/src/tint/writer/glsl/generator_impl_unary_op_test.cc
+++ b/src/tint/writer/glsl/generator_impl_unary_op_test.cc
@@ -80,5 +80,17 @@
     ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
     EXPECT_EQ(out.str(), "-(expr)");
 }
+
+TEST_F(GlslUnaryOpTest, IntMin) {
+    auto* op = Expr(i32(std::numeric_limits<int32_t>::min()));
+    WrapInFunction(op);
+
+    GeneratorImpl& gen = Build();
+
+    utils::StringStream out;
+    ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+    EXPECT_EQ(out.str(), "(-2147483647 - 1)");
+}
+
 }  // namespace
 }  // namespace tint::writer::glsl
diff --git a/src/tint/writer/hlsl/generator.h b/src/tint/writer/hlsl/generator.h
index 74d79ba..2cdfe6f 100644
--- a/src/tint/writer/hlsl/generator.h
+++ b/src/tint/writer/hlsl/generator.h
@@ -28,6 +28,7 @@
 #include "src/tint/sem/binding_point.h"
 #include "src/tint/utils/bitset.h"
 #include "src/tint/writer/array_length_from_uniform_options.h"
+#include "src/tint/writer/external_texture_options.h"
 #include "src/tint/writer/text.h"
 
 // Forward declarations
@@ -58,8 +59,8 @@
     /// Set to `true` to disable workgroup memory zero initialization
     bool disable_workgroup_init = false;
 
-    /// Set to 'true' to generates binding mappings for external textures
-    bool generate_external_texture_bindings = false;
+    /// Options used in the binding mappings for external textures
+    ExternalTextureOptions external_texture_options = {};
 
     /// Options used to specify a mapping of binding points to indices into a UBO
     /// from which to load buffer sizes.
@@ -76,7 +77,7 @@
     TINT_REFLECT(disable_robustness,
                  root_constant_binding_point,
                  disable_workgroup_init,
-                 generate_external_texture_bindings,
+                 external_texture_options,
                  array_length_from_uniform);
 };
 
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index f0247c4..1cfbf64 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -40,6 +40,7 @@
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/add_empty_entry_point.h"
 #include "src/tint/transform/array_length_from_uniform.h"
 #include "src/tint/transform/builtin_polyfill.h"
@@ -52,6 +53,7 @@
 #include "src/tint/transform/expand_compound_assignment.h"
 #include "src/tint/transform/localize_struct_array_assignment.h"
 #include "src/tint/transform/manager.h"
+#include "src/tint/transform/multiplanar_external_texture.h"
 #include "src/tint/transform/num_workgroups_from_uniform.h"
 #include "src/tint/transform/promote_initializers_to_let.h"
 #include "src/tint/transform/promote_side_effects_to_decl.h"
@@ -80,7 +82,6 @@
 #include "src/tint/writer/append_vector.h"
 #include "src/tint/writer/check_supported_extensions.h"
 #include "src/tint/writer/float_to_string.h"
-#include "src/tint/writer/generate_external_texture_bindings.h"
 
 using namespace tint::number_suffixes;  // NOLINT
 
@@ -187,10 +188,10 @@
         manager.Add<transform::Robustness>();
     }
 
-    if (options.generate_external_texture_bindings) {
+    if (!options.external_texture_options.bindings_map.empty()) {
         // Note: it is more efficient for MultiplanarExternalTexture to come after Robustness
-        auto new_bindings_map = GenerateExternalTextureBindings(in);
-        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(new_bindings_map);
+        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(
+            options.external_texture_options.bindings_map);
         manager.Add<transform::MultiplanarExternalTexture>();
     }
 
@@ -203,6 +204,7 @@
         polyfills.clamp_int = true;
         // TODO(crbug.com/tint/1449): Some of these can map to HLSL's `firstbitlow`
         // and `firstbithigh`.
+        polyfills.conv_f32_to_iu32 = true;
         polyfills.count_leading_zeros = true;
         polyfills.count_trailing_zeros = true;
         polyfills.extract_bits = transform::BuiltinPolyfill::Level::kFull;
@@ -966,25 +968,25 @@
     if (builtin->IsTexture()) {
         return EmitTextureCall(out, call, builtin);
     }
-    if (type == sem::BuiltinType::kSelect) {
+    if (type == builtin::Function::kSelect) {
         return EmitSelectCall(out, expr);
     }
-    if (type == sem::BuiltinType::kModf) {
+    if (type == builtin::Function::kModf) {
         return EmitModfCall(out, expr, builtin);
     }
-    if (type == sem::BuiltinType::kFrexp) {
+    if (type == builtin::Function::kFrexp) {
         return EmitFrexpCall(out, expr, builtin);
     }
-    if (type == sem::BuiltinType::kDegrees) {
+    if (type == builtin::Function::kDegrees) {
         return EmitDegreesCall(out, expr, builtin);
     }
-    if (type == sem::BuiltinType::kRadians) {
+    if (type == builtin::Function::kRadians) {
         return EmitRadiansCall(out, expr, builtin);
     }
-    if (type == sem::BuiltinType::kSign) {
+    if (type == builtin::Function::kSign) {
         return EmitSignCall(out, call, builtin);
     }
-    if (type == sem::BuiltinType::kQuantizeToF16) {
+    if (type == builtin::Function::kQuantizeToF16) {
         return EmitQuantizeToF16Call(out, expr, builtin);
     }
     if (builtin->IsDataPacking()) {
@@ -1011,7 +1013,7 @@
     // Handle single argument builtins that only accept and return uint (not int overload). We need
     // to explicitly cast the return value (we also cast the arg for good measure). See
     // crbug.com/tint/1550
-    if (type == sem::BuiltinType::kCountOneBits || type == sem::BuiltinType::kReverseBits) {
+    if (type == builtin::Function::kCountOneBits || type == builtin::Function::kReverseBits) {
         auto* arg = call->Arguments()[0];
         if (arg->Type()->UnwrapRef()->is_signed_integer_scalar_or_vector()) {
             out << "asint(" << name << "(asuint(";
@@ -1805,7 +1807,7 @@
                 if (i > 0) {
                     pre << ", ";
                 }
-                if (i == 1 && builtin->Type() == sem::BuiltinType::kAtomicSub) {
+                if (i == 1 && builtin->Type() == builtin::Function::kAtomicSub) {
                     // Sub uses InterlockedAdd with the operand negated.
                     pre << "-";
                 }
@@ -1824,7 +1826,7 @@
     };
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAtomicLoad: {
+        case builtin::Function::kAtomicLoad: {
             // HLSL does not have an InterlockedLoad, so we emulate it with
             // InterlockedOr using 0 as the OR value
             auto pre = line();
@@ -1841,7 +1843,7 @@
             out << result;
             return true;
         }
-        case sem::BuiltinType::kAtomicStore: {
+        case builtin::Function::kAtomicStore: {
             // HLSL does not have an InterlockedStore, so we emulate it with
             // InterlockedExchange and discard the returned value
             {  // T result = 0;
@@ -1872,7 +1874,7 @@
             }
             return true;
         }
-        case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+        case builtin::Function::kAtomicCompareExchangeWeak: {
             if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
                 return false;
             }
@@ -1921,26 +1923,26 @@
             return true;
         }
 
-        case sem::BuiltinType::kAtomicAdd:
-        case sem::BuiltinType::kAtomicSub:
+        case builtin::Function::kAtomicAdd:
+        case builtin::Function::kAtomicSub:
             return call("InterlockedAdd");
 
-        case sem::BuiltinType::kAtomicMax:
+        case builtin::Function::kAtomicMax:
             return call("InterlockedMax");
 
-        case sem::BuiltinType::kAtomicMin:
+        case builtin::Function::kAtomicMin:
             return call("InterlockedMin");
 
-        case sem::BuiltinType::kAtomicAnd:
+        case builtin::Function::kAtomicAnd:
             return call("InterlockedAnd");
 
-        case sem::BuiltinType::kAtomicOr:
+        case builtin::Function::kAtomicOr:
             return call("InterlockedOr");
 
-        case sem::BuiltinType::kAtomicXor:
+        case builtin::Function::kAtomicXor:
             return call("InterlockedXor");
 
-        case sem::BuiltinType::kAtomicExchange:
+        case builtin::Function::kAtomicExchange:
             return call("InterlockedExchange");
 
         default:
@@ -2114,21 +2116,21 @@
             uint32_t dims = 2;
             bool is_signed = false;
             uint32_t scale = 65535;
-            if (builtin->Type() == sem::BuiltinType::kPack4X8Snorm ||
-                builtin->Type() == sem::BuiltinType::kPack4X8Unorm) {
+            if (builtin->Type() == builtin::Function::kPack4X8Snorm ||
+                builtin->Type() == builtin::Function::kPack4X8Unorm) {
                 dims = 4;
                 scale = 255;
             }
-            if (builtin->Type() == sem::BuiltinType::kPack4X8Snorm ||
-                builtin->Type() == sem::BuiltinType::kPack2X16Snorm) {
+            if (builtin->Type() == builtin::Function::kPack4X8Snorm ||
+                builtin->Type() == builtin::Function::kPack2X16Snorm) {
                 is_signed = true;
                 scale = (scale - 1) / 2;
             }
             switch (builtin->Type()) {
-                case sem::BuiltinType::kPack4X8Snorm:
-                case sem::BuiltinType::kPack4X8Unorm:
-                case sem::BuiltinType::kPack2X16Snorm:
-                case sem::BuiltinType::kPack2X16Unorm: {
+                case builtin::Function::kPack4X8Snorm:
+                case builtin::Function::kPack4X8Unorm:
+                case builtin::Function::kPack2X16Snorm:
+                case builtin::Function::kPack2X16Unorm: {
                     {
                         auto l = line(b);
                         l << (is_signed ? "" : "u") << "int" << dims
@@ -2154,7 +2156,7 @@
                     }
                     break;
                 }
-                case sem::BuiltinType::kPack2X16Float: {
+                case builtin::Function::kPack2X16Float: {
                     line(b) << "uint2 i = f32tof16(" << params[0] << ");";
                     line(b) << "return i.x | (i.y << 16);";
                     break;
@@ -2177,19 +2179,19 @@
             uint32_t dims = 2;
             bool is_signed = false;
             uint32_t scale = 65535;
-            if (builtin->Type() == sem::BuiltinType::kUnpack4X8Snorm ||
-                builtin->Type() == sem::BuiltinType::kUnpack4X8Unorm) {
+            if (builtin->Type() == builtin::Function::kUnpack4X8Snorm ||
+                builtin->Type() == builtin::Function::kUnpack4X8Unorm) {
                 dims = 4;
                 scale = 255;
             }
-            if (builtin->Type() == sem::BuiltinType::kUnpack4X8Snorm ||
-                builtin->Type() == sem::BuiltinType::kUnpack2X16Snorm) {
+            if (builtin->Type() == builtin::Function::kUnpack4X8Snorm ||
+                builtin->Type() == builtin::Function::kUnpack2X16Snorm) {
                 is_signed = true;
                 scale = (scale - 1) / 2;
             }
             switch (builtin->Type()) {
-                case sem::BuiltinType::kUnpack4X8Snorm:
-                case sem::BuiltinType::kUnpack2X16Snorm: {
+                case builtin::Function::kUnpack4X8Snorm:
+                case builtin::Function::kUnpack2X16Snorm: {
                     line(b) << "int j = int(" << params[0] << ");";
                     {  // Perform sign extension on the converted values.
                         auto l = line(b);
@@ -2205,8 +2207,8 @@
                             << (is_signed ? "-1.0" : "0.0") << ", 1.0);";
                     break;
                 }
-                case sem::BuiltinType::kUnpack4X8Unorm:
-                case sem::BuiltinType::kUnpack2X16Unorm: {
+                case builtin::Function::kUnpack4X8Unorm:
+                case builtin::Function::kUnpack2X16Unorm: {
                     line(b) << "uint j = " << params[0] << ";";
                     {
                         auto l = line(b);
@@ -2222,7 +2224,7 @@
                     line(b) << "return float" << dims << "(i) / " << scale << ".0;";
                     break;
                 }
-                case sem::BuiltinType::kUnpack2X16Float:
+                case builtin::Function::kUnpack2X16Float:
                     line(b) << "uint i = " << params[0] << ";";
                     line(b) << "return f16tof32(uint2(i & 0xffff, i >> 16));";
                     break;
@@ -2244,11 +2246,11 @@
         out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
             std::string functionName;
             switch (builtin->Type()) {
-                case sem::BuiltinType::kDot4I8Packed:
+                case builtin::Function::kDot4I8Packed:
                     line(b) << "int accumulator = 0;";
                     functionName = "dot4add_i8packed";
                     break;
-                case sem::BuiltinType::kDot4U8Packed:
+                case builtin::Function::kDot4U8Packed:
                     line(b) << "uint accumulator = 0u;";
                     functionName = "dot4add_u8packed";
                     break;
@@ -2267,13 +2269,13 @@
 bool GeneratorImpl::EmitBarrierCall(utils::StringStream& out, const sem::Builtin* builtin) {
     // TODO(crbug.com/tint/661): Combine sequential barriers to a single
     // instruction.
-    if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+    if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
         out << "GroupMemoryBarrierWithGroupSync()";
-    } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+    } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
         out << "DeviceMemoryBarrierWithGroupSync()";
     } else {
         TINT_UNREACHABLE(Writer, diagnostics_)
-            << "unexpected barrier builtin type " << sem::str(builtin->Type());
+            << "unexpected barrier builtin type " << builtin::str(builtin->Type());
         return false;
     }
     return true;
@@ -2303,10 +2305,10 @@
     auto* texture_type = TypeOf(texture)->UnwrapRef()->As<type::Texture>();
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureDimensions:
-        case sem::BuiltinType::kTextureNumLayers:
-        case sem::BuiltinType::kTextureNumLevels:
-        case sem::BuiltinType::kTextureNumSamples: {
+        case builtin::Function::kTextureDimensions:
+        case builtin::Function::kTextureNumLayers:
+        case builtin::Function::kTextureNumLevels:
+        case builtin::Function::kTextureNumSamples: {
             // All of these builtins use the GetDimensions() method on the texture
             bool is_ms =
                 texture_type->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>();
@@ -2314,7 +2316,7 @@
             std::string swizzle;
 
             switch (builtin->Type()) {
-                case sem::BuiltinType::kTextureDimensions:
+                case builtin::Function::kTextureDimensions:
                     switch (texture_type->dim()) {
                         case type::TextureDimension::kNone:
                             TINT_ICE(Writer, diagnostics_) << "texture dimension is kNone";
@@ -2342,7 +2344,7 @@
                             break;
                     }
                     break;
-                case sem::BuiltinType::kTextureNumLayers:
+                case builtin::Function::kTextureNumLayers:
                     switch (texture_type->dim()) {
                         default:
                             TINT_ICE(Writer, diagnostics_) << "texture dimension is not arrayed";
@@ -2357,7 +2359,7 @@
                             break;
                     }
                     break;
-                case sem::BuiltinType::kTextureNumLevels:
+                case builtin::Function::kTextureNumLevels:
                     switch (texture_type->dim()) {
                         default:
                             TINT_ICE(Writer, diagnostics_)
@@ -2380,7 +2382,7 @@
                             break;
                     }
                     break;
-                case sem::BuiltinType::kTextureNumSamples:
+                case builtin::Function::kTextureNumSamples:
                     switch (texture_type->dim()) {
                         default:
                             TINT_ICE(Writer, diagnostics_)
@@ -2427,9 +2429,9 @@
             // Declare a variable to hold the queried texture info
             auto dims = UniqueIdentifier(kTempNamePrefix);
             if (num_dimensions == 1) {
-                line() << "int " << dims << ";";
+                line() << "uint " << dims << ";";
             } else {
-                line() << "int" << num_dimensions << " " << dims << ";";
+                line() << "uint" << num_dimensions << " " << dims << ";";
             }
 
             {  // texture.GetDimensions(...)
@@ -2444,7 +2446,7 @@
                         return false;
                     }
                     pre << ", ";
-                } else if (builtin->Type() == sem::BuiltinType::kTextureNumLevels) {
+                } else if (builtin->Type() == builtin::Function::kTextureNumLevels) {
                     pre << "0, ";
                 }
 
@@ -2491,34 +2493,34 @@
     uint32_t hlsl_ret_width = 4u;
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureSample:
+        case builtin::Function::kTextureSample:
             out << ".Sample(";
             break;
-        case sem::BuiltinType::kTextureSampleBias:
+        case builtin::Function::kTextureSampleBias:
             out << ".SampleBias(";
             break;
-        case sem::BuiltinType::kTextureSampleLevel:
+        case builtin::Function::kTextureSampleLevel:
             out << ".SampleLevel(";
             break;
-        case sem::BuiltinType::kTextureSampleGrad:
+        case builtin::Function::kTextureSampleGrad:
             out << ".SampleGrad(";
             break;
-        case sem::BuiltinType::kTextureSampleCompare:
+        case builtin::Function::kTextureSampleCompare:
             out << ".SampleCmp(";
             hlsl_ret_width = 1;
             break;
-        case sem::BuiltinType::kTextureSampleCompareLevel:
+        case builtin::Function::kTextureSampleCompareLevel:
             out << ".SampleCmpLevelZero(";
             hlsl_ret_width = 1;
             break;
-        case sem::BuiltinType::kTextureLoad:
+        case builtin::Function::kTextureLoad:
             out << ".Load(";
             // Multisampled textures do not support mip-levels.
             if (!texture_type->Is<type::MultisampledTexture>()) {
                 pack_level_in_coords = true;
             }
             break;
-        case sem::BuiltinType::kTextureGather:
+        case builtin::Function::kTextureGather:
             out << ".Gather";
             if (builtin->Parameters()[0]->Usage() == sem::ParameterUsage::kComponent) {
                 switch (call->Arguments()[0]->ConstantValue()->ValueAs<AInt>()) {
@@ -2538,10 +2540,10 @@
             }
             out << "(";
             break;
-        case sem::BuiltinType::kTextureGatherCompare:
+        case builtin::Function::kTextureGatherCompare:
             out << ".GatherCmp(";
             break;
-        case sem::BuiltinType::kTextureStore:
+        case builtin::Function::kTextureStore:
             out << "[";
             break;
         default:
@@ -2621,7 +2623,7 @@
         }
     }
 
-    if (builtin->Type() == sem::BuiltinType::kTextureStore) {
+    if (builtin->Type() == builtin::Function::kTextureStore) {
         out << "] = ";
         if (!EmitExpression(out, arg(Usage::kValue))) {
             return false;
@@ -2655,78 +2657,78 @@
 
 std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAbs:
-        case sem::BuiltinType::kAcos:
-        case sem::BuiltinType::kAll:
-        case sem::BuiltinType::kAny:
-        case sem::BuiltinType::kAsin:
-        case sem::BuiltinType::kAtan:
-        case sem::BuiltinType::kAtan2:
-        case sem::BuiltinType::kCeil:
-        case sem::BuiltinType::kClamp:
-        case sem::BuiltinType::kCos:
-        case sem::BuiltinType::kCosh:
-        case sem::BuiltinType::kCross:
-        case sem::BuiltinType::kDeterminant:
-        case sem::BuiltinType::kDistance:
-        case sem::BuiltinType::kDot:
-        case sem::BuiltinType::kExp:
-        case sem::BuiltinType::kExp2:
-        case sem::BuiltinType::kFloor:
-        case sem::BuiltinType::kFrexp:
-        case sem::BuiltinType::kLdexp:
-        case sem::BuiltinType::kLength:
-        case sem::BuiltinType::kLog:
-        case sem::BuiltinType::kLog2:
-        case sem::BuiltinType::kMax:
-        case sem::BuiltinType::kMin:
-        case sem::BuiltinType::kModf:
-        case sem::BuiltinType::kNormalize:
-        case sem::BuiltinType::kPow:
-        case sem::BuiltinType::kReflect:
-        case sem::BuiltinType::kRefract:
-        case sem::BuiltinType::kRound:
-        case sem::BuiltinType::kSaturate:
-        case sem::BuiltinType::kSin:
-        case sem::BuiltinType::kSinh:
-        case sem::BuiltinType::kSqrt:
-        case sem::BuiltinType::kStep:
-        case sem::BuiltinType::kTan:
-        case sem::BuiltinType::kTanh:
-        case sem::BuiltinType::kTranspose:
-        case sem::BuiltinType::kTrunc:
+        case builtin::Function::kAbs:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAtan:
+        case builtin::Function::kAtan2:
+        case builtin::Function::kCeil:
+        case builtin::Function::kClamp:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kCross:
+        case builtin::Function::kDeterminant:
+        case builtin::Function::kDistance:
+        case builtin::Function::kDot:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFrexp:
+        case builtin::Function::kLdexp:
+        case builtin::Function::kLength:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kMax:
+        case builtin::Function::kMin:
+        case builtin::Function::kModf:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kRefract:
+        case builtin::Function::kRound:
+        case builtin::Function::kSaturate:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kStep:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTranspose:
+        case builtin::Function::kTrunc:
             return builtin->str();
-        case sem::BuiltinType::kCountOneBits:  // uint
+        case builtin::Function::kCountOneBits:  // uint
             return "countbits";
-        case sem::BuiltinType::kDpdx:
+        case builtin::Function::kDpdx:
             return "ddx";
-        case sem::BuiltinType::kDpdxCoarse:
+        case builtin::Function::kDpdxCoarse:
             return "ddx_coarse";
-        case sem::BuiltinType::kDpdxFine:
+        case builtin::Function::kDpdxFine:
             return "ddx_fine";
-        case sem::BuiltinType::kDpdy:
+        case builtin::Function::kDpdy:
             return "ddy";
-        case sem::BuiltinType::kDpdyCoarse:
+        case builtin::Function::kDpdyCoarse:
             return "ddy_coarse";
-        case sem::BuiltinType::kDpdyFine:
+        case builtin::Function::kDpdyFine:
             return "ddy_fine";
-        case sem::BuiltinType::kFaceForward:
+        case builtin::Function::kFaceForward:
             return "faceforward";
-        case sem::BuiltinType::kFract:
+        case builtin::Function::kFract:
             return "frac";
-        case sem::BuiltinType::kFma:
+        case builtin::Function::kFma:
             return "mad";
-        case sem::BuiltinType::kFwidth:
-        case sem::BuiltinType::kFwidthCoarse:
-        case sem::BuiltinType::kFwidthFine:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
             return "fwidth";
-        case sem::BuiltinType::kInverseSqrt:
+        case builtin::Function::kInverseSqrt:
             return "rsqrt";
-        case sem::BuiltinType::kMix:
+        case builtin::Function::kMix:
             return "lerp";
-        case sem::BuiltinType::kReverseBits:  // uint
+        case builtin::Function::kReverseBits:  // uint
             return "reversebits";
-        case sem::BuiltinType::kSmoothstep:
+        case builtin::Function::kSmoothstep:
             return "smoothstep";
         default:
             diagnostics_.add_error(diag::System::Writer,
@@ -3321,10 +3323,10 @@
             return true;
         },
         [&](const type::Vector* v) {
-            if (constant->AllEqual()) {
+            if (auto* splat = constant->As<constant::Splat>()) {
                 {
                     ScopedParen sp(out);
-                    if (!EmitConstant(out, constant->Index(0), is_variable_initializer)) {
+                    if (!EmitConstant(out, splat->el, is_variable_initializer)) {
                         return false;
                     }
                 }
@@ -4346,7 +4348,7 @@
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
-        auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+        auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
         std::vector<std::string> parameter_names;
         {
             auto decl = line(&b);
diff --git a/src/tint/writer/hlsl/generator_impl_builtin_test.cc b/src/tint/writer/hlsl/generator_impl_builtin_test.cc
index 5054327..f473ac8 100644
--- a/src/tint/writer/hlsl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_builtin_test.cc
@@ -26,7 +26,6 @@
 namespace tint::writer::hlsl {
 namespace {
 
-using BuiltinType = sem::BuiltinType;
 using HlslGeneratorImplTest_Builtin = TestHelper;
 
 enum class CallParamType {
@@ -37,7 +36,7 @@
 };
 
 struct BuiltinData {
-    BuiltinType builtin;
+    builtin::Function builtin;
     CallParamType type;
     const char* hlsl_name;
 };
@@ -61,85 +60,85 @@
     return out;
 }
 
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
                                         CallParamType type,
                                         ProgramBuilder* builder) {
     std::string name;
     utils::StringStream str;
     str << name << builtin;
     switch (builtin) {
-        case BuiltinType::kAcos:
-        case BuiltinType::kAsin:
-        case BuiltinType::kAtan:
-        case BuiltinType::kCeil:
-        case BuiltinType::kCos:
-        case BuiltinType::kCosh:
-        case BuiltinType::kDpdx:
-        case BuiltinType::kDpdxCoarse:
-        case BuiltinType::kDpdxFine:
-        case BuiltinType::kDpdy:
-        case BuiltinType::kDpdyCoarse:
-        case BuiltinType::kDpdyFine:
-        case BuiltinType::kExp:
-        case BuiltinType::kExp2:
-        case BuiltinType::kFloor:
-        case BuiltinType::kFract:
-        case BuiltinType::kFwidth:
-        case BuiltinType::kFwidthCoarse:
-        case BuiltinType::kFwidthFine:
-        case BuiltinType::kInverseSqrt:
-        case BuiltinType::kLength:
-        case BuiltinType::kLog:
-        case BuiltinType::kLog2:
-        case BuiltinType::kNormalize:
-        case BuiltinType::kRound:
-        case BuiltinType::kSin:
-        case BuiltinType::kSinh:
-        case BuiltinType::kSqrt:
-        case BuiltinType::kTan:
-        case BuiltinType::kTanh:
-        case BuiltinType::kTrunc:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAtan:
+        case builtin::Function::kCeil:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kDpdx:
+        case builtin::Function::kDpdxCoarse:
+        case builtin::Function::kDpdxFine:
+        case builtin::Function::kDpdy:
+        case builtin::Function::kDpdyCoarse:
+        case builtin::Function::kDpdyFine:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFract:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
+        case builtin::Function::kInverseSqrt:
+        case builtin::Function::kLength:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kRound:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTrunc:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2");
             } else {
                 return builder->Call(str.str(), "f2");
             }
-        case BuiltinType::kLdexp:
+        case builtin::Function::kLdexp:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "i2");
             } else {
                 return builder->Call(str.str(), "f2", "i2");
             }
-        case BuiltinType::kAtan2:
-        case BuiltinType::kDot:
-        case BuiltinType::kDistance:
-        case BuiltinType::kPow:
-        case BuiltinType::kReflect:
-        case BuiltinType::kStep:
+        case builtin::Function::kAtan2:
+        case builtin::Function::kDot:
+        case builtin::Function::kDistance:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kStep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2");
             }
-        case BuiltinType::kCross:
+        case builtin::Function::kCross:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h3", "h3");
             } else {
                 return builder->Call(str.str(), "f3", "f3");
             }
-        case BuiltinType::kFma:
-        case BuiltinType::kMix:
-        case BuiltinType::kFaceForward:
-        case BuiltinType::kSmoothstep:
+        case builtin::Function::kFma:
+        case builtin::Function::kMix:
+        case builtin::Function::kFaceForward:
+        case builtin::Function::kSmoothstep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             }
-        case BuiltinType::kAll:
-        case BuiltinType::kAny:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
             return builder->Call(str.str(), "b2");
-        case BuiltinType::kAbs:
+        case builtin::Function::kAbs:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2");
             } else if (type == CallParamType::kF16) {
@@ -147,11 +146,11 @@
             } else {
                 return builder->Call(str.str(), "u2");
             }
-        case BuiltinType::kCountOneBits:
-        case BuiltinType::kReverseBits:
+        case builtin::Function::kCountOneBits:
+        case builtin::Function::kReverseBits:
             return builder->Call(str.str(), "u2");
-        case BuiltinType::kMax:
-        case BuiltinType::kMin:
+        case builtin::Function::kMax:
+        case builtin::Function::kMin:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -159,7 +158,7 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2");
             }
-        case BuiltinType::kClamp:
+        case builtin::Function::kClamp:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -167,19 +166,19 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2", "u2");
             }
-        case BuiltinType::kSelect:
+        case builtin::Function::kSelect:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "b2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "b2");
             }
-        case BuiltinType::kDeterminant:
+        case builtin::Function::kDeterminant:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm2x2");
             } else {
                 return builder->Call(str.str(), "m2x2");
             }
-        case BuiltinType::kTranspose:
+        case builtin::Function::kTranspose:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm3x2");
             } else {
@@ -235,107 +234,112 @@
     HlslGeneratorImplTest_Builtin,
     HlslBuiltinTest,
     testing::Values(/* Logical built-in */
-                    BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
-                    BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
+                    BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+                    BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
                     /* Float built-in */
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "abs"},
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "abs"},
-                    BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
-                    BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
-                    BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
-                    BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
-                    BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
-                    BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
-                    BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan2"},
-                    BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan2"},
-                    BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
-                    BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
-                    BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
-                    BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
-                    BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
-                    BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
-                    BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
-                    BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
-                    BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
-                    BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
-                    BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
-                    BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
-                    BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
-                    BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
-                    BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
-                    BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
-                    BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
-                    BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
-                    BuiltinData{BuiltinType::kFma, CallParamType::kF32, "mad"},
-                    BuiltinData{BuiltinType::kFma, CallParamType::kF16, "mad"},
-                    BuiltinData{BuiltinType::kFract, CallParamType::kF32, "frac"},
-                    BuiltinData{BuiltinType::kFract, CallParamType::kF16, "frac"},
-                    BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "rsqrt"},
-                    BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "rsqrt"},
-                    BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
-                    BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
-                    BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
-                    BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
-                    BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
-                    BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
-                    BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
-                    BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kF32, "max"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kF16, "max"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kF32, "min"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kF16, "min"},
-                    BuiltinData{BuiltinType::kMix, CallParamType::kF32, "lerp"},
-                    BuiltinData{BuiltinType::kMix, CallParamType::kF16, "lerp"},
-                    BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
-                    BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
-                    BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
-                    BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
-                    BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
-                    BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
-                    BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
-                    BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
-                    BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
-                    BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
-                    BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
-                    BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
-                    BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
-                    BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
-                    BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
-                    BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
-                    BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
-                    BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
-                    BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
-                    BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
-                    BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
-                    BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
+                    BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "abs"},
+                    BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "abs"},
+                    BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+                    BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+                    BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+                    BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+                    BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+                    BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+                    BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan2"},
+                    BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan2"},
+                    BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+                    BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+                    BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+                    BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+                    BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+                    BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+                    BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+                    BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+                    BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+                    BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+                    BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+                    BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+                    BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+                    BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+                    BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+                    BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+                    BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32,
+                                "faceforward"},
+                    BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16,
+                                "faceforward"},
+                    BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+                    BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+                    BuiltinData{builtin::Function::kFma, CallParamType::kF32, "mad"},
+                    BuiltinData{builtin::Function::kFma, CallParamType::kF16, "mad"},
+                    BuiltinData{builtin::Function::kFract, CallParamType::kF32, "frac"},
+                    BuiltinData{builtin::Function::kFract, CallParamType::kF16, "frac"},
+                    BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+                    BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+                    BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+                    BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+                    BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+                    BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+                    BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+                    BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+                    BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+                    BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+                    BuiltinData{builtin::Function::kMax, CallParamType::kF32, "max"},
+                    BuiltinData{builtin::Function::kMax, CallParamType::kF16, "max"},
+                    BuiltinData{builtin::Function::kMin, CallParamType::kF32, "min"},
+                    BuiltinData{builtin::Function::kMin, CallParamType::kF16, "min"},
+                    BuiltinData{builtin::Function::kMix, CallParamType::kF32, "lerp"},
+                    BuiltinData{builtin::Function::kMix, CallParamType::kF16, "lerp"},
+                    BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+                    BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+                    BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+                    BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+                    BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+                    BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+                    BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+                    BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+                    BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+                    BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+                    BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+                    BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+                    BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+                    BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+                    BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+                    BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+                    BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+                    BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+                    BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+                    BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+                    BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+                    BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
                     /* Integer built-in */
-                    BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
-                    BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
-                    BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "countbits"},
-                    BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
-                    BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
-                    BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "reversebits"},
-                    BuiltinData{BuiltinType::kRound, CallParamType::kU32, "round"},
+                    BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+                    BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+                    BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "countbits"},
+                    BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+                    BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+                    BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32,
+                                "reversebits"},
+                    BuiltinData{builtin::Function::kRound, CallParamType::kU32, "round"},
                     /* Matrix built-in */
-                    BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
-                    BuiltinData{BuiltinType::kDeterminant, CallParamType::kF16, "determinant"},
-                    BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
-                    BuiltinData{BuiltinType::kTranspose, CallParamType::kF16, "transpose"},
+                    BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32,
+                                "determinant"},
+                    BuiltinData{builtin::Function::kDeterminant, CallParamType::kF16,
+                                "determinant"},
+                    BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
+                    BuiltinData{builtin::Function::kTranspose, CallParamType::kF16, "transpose"},
                     /* Vector built-in */
-                    BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
-                    BuiltinData{BuiltinType::kDot, CallParamType::kF16, "dot"},
+                    BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
+                    BuiltinData{builtin::Function::kDot, CallParamType::kF16, "dot"},
                     /* Derivate built-in */
-                    BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "ddx"},
-                    BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
-                    BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "ddx_fine"},
-                    BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "ddy"},
-                    BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
-                    BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "ddy_fine"},
-                    BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
-                    BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
-                    BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"}));
+                    BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "ddx"},
+                    BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
+                    BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "ddx_fine"},
+                    BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "ddy"},
+                    BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
+                    BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "ddy_fine"},
+                    BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+                    BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+                    BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
 
 TEST_F(HlslGeneratorImplTest_Builtin, Builtin_Call) {
     auto* call = Call("dot", "param1", "param2");
diff --git a/src/tint/writer/hlsl/generator_impl_builtin_texture_test.cc b/src/tint/writer/hlsl/generator_impl_builtin_texture_test.cc
index 6751790..4d7165b 100644
--- a/src/tint/writer/hlsl/generator_impl_builtin_texture_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_builtin_texture_test.cc
@@ -170,6 +170,8 @@
             return R"(tint_symbol.GatherCmp(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u)), 5.0f))";
         case ValidTextureOverload::kNumLayers2dArray:
         case ValidTextureOverload::kNumLayersDepth2dArray:
+        case ValidTextureOverload::kNumLayersCubeArray:
+        case ValidTextureOverload::kNumLayersDepthCubeArray:
         case ValidTextureOverload::kNumLayersStorageWO2dArray:
             return {
                 R"(int3 tint_tmp;
diff --git a/src/tint/writer/msl/generator.h b/src/tint/writer/msl/generator.h
index 1add259..b4e11d9 100644
--- a/src/tint/writer/msl/generator.h
+++ b/src/tint/writer/msl/generator.h
@@ -23,6 +23,7 @@
 
 #include "src/tint/reflection.h"
 #include "src/tint/writer/array_length_from_uniform_options.h"
+#include "src/tint/writer/external_texture_options.h"
 #include "src/tint/writer/text.h"
 
 // Forward declarations
@@ -62,8 +63,8 @@
     /// Set to `true` to disable workgroup memory zero initialization
     bool disable_workgroup_init = false;
 
-    /// Set to 'true' to generates binding mappings for external textures
-    bool generate_external_texture_bindings = false;
+    /// Options used in the binding mappings for external textures
+    ExternalTextureOptions external_texture_options = {};
 
     /// Options used to specify a mapping of binding points to indices into a UBO
     /// from which to load buffer sizes.
@@ -75,7 +76,7 @@
                  fixed_sample_mask,
                  emit_vertex_point_size,
                  disable_workgroup_init,
-                 generate_external_texture_bindings,
+                 external_texture_options,
                  array_length_from_uniform);
 };
 
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 5c9e11b..268736f 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -40,6 +40,7 @@
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/variable.h"
+#include "src/tint/switch.h"
 #include "src/tint/transform/array_length_from_uniform.h"
 #include "src/tint/transform/builtin_polyfill.h"
 #include "src/tint/transform/canonicalize_entry_point_io.h"
@@ -48,6 +49,7 @@
 #include "src/tint/transform/expand_compound_assignment.h"
 #include "src/tint/transform/manager.h"
 #include "src/tint/transform/module_scope_var_to_entry_point_param.h"
+#include "src/tint/transform/multiplanar_external_texture.h"
 #include "src/tint/transform/packed_vec3.h"
 #include "src/tint/transform/preserve_padding.h"
 #include "src/tint/transform/promote_initializers_to_let.h"
@@ -82,7 +84,6 @@
 #include "src/tint/utils/string_stream.h"
 #include "src/tint/writer/check_supported_extensions.h"
 #include "src/tint/writer/float_to_string.h"
-#include "src/tint/writer/generate_external_texture_bindings.h"
 
 namespace tint::writer::msl {
 namespace {
@@ -218,6 +219,7 @@
         polyfills.atanh = transform::BuiltinPolyfill::Level::kRangeCheck;
         polyfills.bitshift_modulo = true;  // crbug.com/tint/1543
         polyfills.clamp_int = true;
+        polyfills.conv_f32_to_iu32 = true;
         polyfills.extract_bits = transform::BuiltinPolyfill::Level::kClampParameters;
         polyfills.first_leading_bit = true;
         polyfills.first_trailing_bit = true;
@@ -230,10 +232,10 @@
         manager.Add<transform::BuiltinPolyfill>();
     }
 
-    if (options.generate_external_texture_bindings) {
+    if (!options.external_texture_options.bindings_map.empty()) {
         // Note: it is more efficient for MultiplanarExternalTexture to come after Robustness
-        auto new_bindings_map = GenerateExternalTextureBindings(in);
-        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(new_bindings_map);
+        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(
+            options.external_texture_options.bindings_map);
         manager.Add<transform::MultiplanarExternalTexture>();
     }
 
@@ -699,20 +701,20 @@
     auto name = generate_builtin_name(builtin);
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kDot:
+        case builtin::Function::kDot:
             return EmitDotCall(out, expr, builtin);
-        case sem::BuiltinType::kModf:
+        case builtin::Function::kModf:
             return EmitModfCall(out, expr, builtin);
-        case sem::BuiltinType::kFrexp:
+        case builtin::Function::kFrexp:
             return EmitFrexpCall(out, expr, builtin);
-        case sem::BuiltinType::kDegrees:
+        case builtin::Function::kDegrees:
             return EmitDegreesCall(out, expr, builtin);
-        case sem::BuiltinType::kRadians:
+        case builtin::Function::kRadians:
             return EmitRadiansCall(out, expr, builtin);
 
-        case sem::BuiltinType::kPack2X16Float:
-        case sem::BuiltinType::kUnpack2X16Float: {
-            if (builtin->Type() == sem::BuiltinType::kPack2X16Float) {
+        case builtin::Function::kPack2X16Float:
+        case builtin::Function::kUnpack2X16Float: {
+            if (builtin->Type() == builtin::Function::kPack2X16Float) {
                 out << "as_type<uint>(half2(";
             } else {
                 out << "float2(as_type<half2>(";
@@ -723,7 +725,7 @@
             out << "))";
             return true;
         }
-        case sem::BuiltinType::kQuantizeToF16: {
+        case builtin::Function::kQuantizeToF16: {
             std::string width = "";
             if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
                 width = std::to_string(vec->Width());
@@ -737,16 +739,16 @@
         }
         // TODO(crbug.com/tint/661): Combine sequential barriers to a single
         // instruction.
-        case sem::BuiltinType::kStorageBarrier: {
+        case builtin::Function::kStorageBarrier: {
             out << "threadgroup_barrier(mem_flags::mem_device)";
             return true;
         }
-        case sem::BuiltinType::kWorkgroupBarrier: {
+        case builtin::Function::kWorkgroupBarrier: {
             out << "threadgroup_barrier(mem_flags::mem_threadgroup)";
             return true;
         }
 
-        case sem::BuiltinType::kLength: {
+        case builtin::Function::kLength: {
             auto* sem = builder_.Sem().GetVal(expr->args[0]);
             if (sem->Type()->UnwrapRef()->is_scalar()) {
                 // Emulate scalar overload using fabs(x).
@@ -755,7 +757,7 @@
             break;
         }
 
-        case sem::BuiltinType::kDistance: {
+        case builtin::Function::kDistance: {
             auto* sem = builder_.Sem().GetVal(expr->args[0]);
             if (sem->Type()->UnwrapRef()->is_scalar()) {
                 // Emulate scalar overload using fabs(x - y);
@@ -896,37 +898,37 @@
     };
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAtomicLoad:
+        case builtin::Function::kAtomicLoad:
             return call("atomic_load_explicit", true);
 
-        case sem::BuiltinType::kAtomicStore:
+        case builtin::Function::kAtomicStore:
             return call("atomic_store_explicit", true);
 
-        case sem::BuiltinType::kAtomicAdd:
+        case builtin::Function::kAtomicAdd:
             return call("atomic_fetch_add_explicit", true);
 
-        case sem::BuiltinType::kAtomicSub:
+        case builtin::Function::kAtomicSub:
             return call("atomic_fetch_sub_explicit", true);
 
-        case sem::BuiltinType::kAtomicMax:
+        case builtin::Function::kAtomicMax:
             return call("atomic_fetch_max_explicit", true);
 
-        case sem::BuiltinType::kAtomicMin:
+        case builtin::Function::kAtomicMin:
             return call("atomic_fetch_min_explicit", true);
 
-        case sem::BuiltinType::kAtomicAnd:
+        case builtin::Function::kAtomicAnd:
             return call("atomic_fetch_and_explicit", true);
 
-        case sem::BuiltinType::kAtomicOr:
+        case builtin::Function::kAtomicOr:
             return call("atomic_fetch_or_explicit", true);
 
-        case sem::BuiltinType::kAtomicXor:
+        case builtin::Function::kAtomicXor:
             return call("atomic_fetch_xor_explicit", true);
 
-        case sem::BuiltinType::kAtomicExchange:
+        case builtin::Function::kAtomicExchange:
             return call("atomic_exchange_explicit", true);
 
-        case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+        case builtin::Function::kAtomicCompareExchangeWeak: {
             auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<type::Pointer>();
             auto sc = ptr_ty->AddressSpace();
             auto* str = builtin->ReturnType()->As<sem::Struct>();
@@ -1041,7 +1043,7 @@
     bool level_is_constant_zero = texture_type->dim() == type::TextureDimension::k1d;
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureDimensions: {
+        case builtin::Function::kTextureDimensions: {
             std::vector<const char*> dims;
             switch (texture_type->dim()) {
                 case type::TextureDimension::kNone:
@@ -1094,21 +1096,21 @@
             }
             return true;
         }
-        case sem::BuiltinType::kTextureNumLayers: {
+        case builtin::Function::kTextureNumLayers: {
             if (!texture_expr()) {
                 return false;
             }
             out << ".get_array_size()";
             return true;
         }
-        case sem::BuiltinType::kTextureNumLevels: {
+        case builtin::Function::kTextureNumLevels: {
             if (!texture_expr()) {
                 return false;
             }
             out << ".get_num_mip_levels()";
             return true;
         }
-        case sem::BuiltinType::kTextureNumSamples: {
+        case builtin::Function::kTextureNumSamples: {
             if (!texture_expr()) {
                 return false;
             }
@@ -1126,27 +1128,27 @@
     bool lod_param_is_named = true;
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kTextureSample:
-        case sem::BuiltinType::kTextureSampleBias:
-        case sem::BuiltinType::kTextureSampleLevel:
-        case sem::BuiltinType::kTextureSampleGrad:
+        case builtin::Function::kTextureSample:
+        case builtin::Function::kTextureSampleBias:
+        case builtin::Function::kTextureSampleLevel:
+        case builtin::Function::kTextureSampleGrad:
             out << ".sample(";
             break;
-        case sem::BuiltinType::kTextureSampleCompare:
-        case sem::BuiltinType::kTextureSampleCompareLevel:
+        case builtin::Function::kTextureSampleCompare:
+        case builtin::Function::kTextureSampleCompareLevel:
             out << ".sample_compare(";
             break;
-        case sem::BuiltinType::kTextureGather:
+        case builtin::Function::kTextureGather:
             out << ".gather(";
             break;
-        case sem::BuiltinType::kTextureGatherCompare:
+        case builtin::Function::kTextureGatherCompare:
             out << ".gather_compare(";
             break;
-        case sem::BuiltinType::kTextureLoad:
+        case builtin::Function::kTextureLoad:
             out << ".read(";
             lod_param_is_named = false;
             break;
-        case sem::BuiltinType::kTextureStore:
+        case builtin::Function::kTextureStore:
             out << ".write(";
             break;
         default:
@@ -1223,7 +1225,7 @@
             out << ")";
         }
     }
-    if (builtin->Type() == sem::BuiltinType::kTextureSampleCompareLevel) {
+    if (builtin->Type() == builtin::Function::kTextureSampleCompareLevel) {
         maybe_write_comma();
         out << "level(0)";
     }
@@ -1430,143 +1432,143 @@
 std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
     std::string out = "";
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAcos:
-        case sem::BuiltinType::kAcosh:
-        case sem::BuiltinType::kAll:
-        case sem::BuiltinType::kAny:
-        case sem::BuiltinType::kAsin:
-        case sem::BuiltinType::kAsinh:
-        case sem::BuiltinType::kAtanh:
-        case sem::BuiltinType::kAtan:
-        case sem::BuiltinType::kAtan2:
-        case sem::BuiltinType::kCeil:
-        case sem::BuiltinType::kCos:
-        case sem::BuiltinType::kCosh:
-        case sem::BuiltinType::kCross:
-        case sem::BuiltinType::kDeterminant:
-        case sem::BuiltinType::kDistance:
-        case sem::BuiltinType::kDot:
-        case sem::BuiltinType::kExp:
-        case sem::BuiltinType::kExp2:
-        case sem::BuiltinType::kFloor:
-        case sem::BuiltinType::kFma:
-        case sem::BuiltinType::kFract:
-        case sem::BuiltinType::kFrexp:
-        case sem::BuiltinType::kLength:
-        case sem::BuiltinType::kLdexp:
-        case sem::BuiltinType::kLog:
-        case sem::BuiltinType::kLog2:
-        case sem::BuiltinType::kMix:
-        case sem::BuiltinType::kModf:
-        case sem::BuiltinType::kNormalize:
-        case sem::BuiltinType::kPow:
-        case sem::BuiltinType::kReflect:
-        case sem::BuiltinType::kRefract:
-        case sem::BuiltinType::kSaturate:
-        case sem::BuiltinType::kSelect:
-        case sem::BuiltinType::kSin:
-        case sem::BuiltinType::kSinh:
-        case sem::BuiltinType::kSqrt:
-        case sem::BuiltinType::kStep:
-        case sem::BuiltinType::kTan:
-        case sem::BuiltinType::kTanh:
-        case sem::BuiltinType::kTranspose:
-        case sem::BuiltinType::kTrunc:
-        case sem::BuiltinType::kSign:
-        case sem::BuiltinType::kClamp:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAcosh:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAsinh:
+        case builtin::Function::kAtanh:
+        case builtin::Function::kAtan:
+        case builtin::Function::kAtan2:
+        case builtin::Function::kCeil:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kCross:
+        case builtin::Function::kDeterminant:
+        case builtin::Function::kDistance:
+        case builtin::Function::kDot:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFma:
+        case builtin::Function::kFract:
+        case builtin::Function::kFrexp:
+        case builtin::Function::kLength:
+        case builtin::Function::kLdexp:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kMix:
+        case builtin::Function::kModf:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kRefract:
+        case builtin::Function::kSaturate:
+        case builtin::Function::kSelect:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kStep:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTranspose:
+        case builtin::Function::kTrunc:
+        case builtin::Function::kSign:
+        case builtin::Function::kClamp:
             out += builtin->str();
             break;
-        case sem::BuiltinType::kAbs:
+        case builtin::Function::kAbs:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 out += "fabs";
             } else {
                 out += "abs";
             }
             break;
-        case sem::BuiltinType::kCountLeadingZeros:
+        case builtin::Function::kCountLeadingZeros:
             out += "clz";
             break;
-        case sem::BuiltinType::kCountOneBits:
+        case builtin::Function::kCountOneBits:
             out += "popcount";
             break;
-        case sem::BuiltinType::kCountTrailingZeros:
+        case builtin::Function::kCountTrailingZeros:
             out += "ctz";
             break;
-        case sem::BuiltinType::kDpdx:
-        case sem::BuiltinType::kDpdxCoarse:
-        case sem::BuiltinType::kDpdxFine:
+        case builtin::Function::kDpdx:
+        case builtin::Function::kDpdxCoarse:
+        case builtin::Function::kDpdxFine:
             out += "dfdx";
             break;
-        case sem::BuiltinType::kDpdy:
-        case sem::BuiltinType::kDpdyCoarse:
-        case sem::BuiltinType::kDpdyFine:
+        case builtin::Function::kDpdy:
+        case builtin::Function::kDpdyCoarse:
+        case builtin::Function::kDpdyFine:
             out += "dfdy";
             break;
-        case sem::BuiltinType::kExtractBits:
+        case builtin::Function::kExtractBits:
             out += "extract_bits";
             break;
-        case sem::BuiltinType::kInsertBits:
+        case builtin::Function::kInsertBits:
             out += "insert_bits";
             break;
-        case sem::BuiltinType::kFwidth:
-        case sem::BuiltinType::kFwidthCoarse:
-        case sem::BuiltinType::kFwidthFine:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
             out += "fwidth";
             break;
-        case sem::BuiltinType::kMax:
+        case builtin::Function::kMax:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 out += "fmax";
             } else {
                 out += "max";
             }
             break;
-        case sem::BuiltinType::kMin:
+        case builtin::Function::kMin:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 out += "fmin";
             } else {
                 out += "min";
             }
             break;
-        case sem::BuiltinType::kFaceForward:
+        case builtin::Function::kFaceForward:
             out += "faceforward";
             break;
-        case sem::BuiltinType::kPack4X8Snorm:
+        case builtin::Function::kPack4X8Snorm:
             out += "pack_float_to_snorm4x8";
             break;
-        case sem::BuiltinType::kPack4X8Unorm:
+        case builtin::Function::kPack4X8Unorm:
             out += "pack_float_to_unorm4x8";
             break;
-        case sem::BuiltinType::kPack2X16Snorm:
+        case builtin::Function::kPack2X16Snorm:
             out += "pack_float_to_snorm2x16";
             break;
-        case sem::BuiltinType::kPack2X16Unorm:
+        case builtin::Function::kPack2X16Unorm:
             out += "pack_float_to_unorm2x16";
             break;
-        case sem::BuiltinType::kReverseBits:
+        case builtin::Function::kReverseBits:
             out += "reverse_bits";
             break;
-        case sem::BuiltinType::kRound:
+        case builtin::Function::kRound:
             out += "rint";
             break;
-        case sem::BuiltinType::kSmoothstep:
+        case builtin::Function::kSmoothstep:
             out += "smoothstep";
             break;
-        case sem::BuiltinType::kInverseSqrt:
+        case builtin::Function::kInverseSqrt:
             out += "rsqrt";
             break;
-        case sem::BuiltinType::kUnpack4X8Snorm:
+        case builtin::Function::kUnpack4X8Snorm:
             out += "unpack_snorm4x8_to_float";
             break;
-        case sem::BuiltinType::kUnpack4X8Unorm:
+        case builtin::Function::kUnpack4X8Unorm:
             out += "unpack_unorm4x8_to_float";
             break;
-        case sem::BuiltinType::kUnpack2X16Snorm:
+        case builtin::Function::kUnpack2X16Snorm:
             out += "unpack_snorm2x16_to_float";
             break;
-        case sem::BuiltinType::kUnpack2X16Unorm:
+        case builtin::Function::kUnpack2X16Unorm:
             out += "unpack_unorm2x16_to_float";
             break;
-        case sem::BuiltinType::kArrayLength:
+        case builtin::Function::kArrayLength:
             diagnostics_.add_error(
                 diag::System::Writer,
                 "Unable to translate builtin: " + std::string(builtin->str()) +
@@ -1707,8 +1709,8 @@
 
             ScopedParen sp(out);
 
-            if (constant->AllEqual()) {
-                if (!EmitConstant(out, constant->Index(0))) {
+            if (auto* splat = constant->As<constant::Splat>()) {
+                if (!EmitConstant(out, splat->el)) {
                     return false;
                 }
                 return true;
@@ -3258,7 +3260,7 @@
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
-        auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+        auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
         std::vector<std::string> parameter_names;
         {
             auto decl = line(&b);
diff --git a/src/tint/writer/msl/generator_impl_builtin_test.cc b/src/tint/writer/msl/generator_impl_builtin_test.cc
index 08a2d25..6c70abe 100644
--- a/src/tint/writer/msl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/msl/generator_impl_builtin_test.cc
@@ -22,8 +22,6 @@
 namespace tint::writer::msl {
 namespace {
 
-using BuiltinType = sem::BuiltinType;
-
 using MslGeneratorImplTest = TestHelper;
 
 enum class CallParamType {
@@ -34,7 +32,7 @@
 };
 
 struct BuiltinData {
-    BuiltinType builtin;
+    builtin::Function builtin;
     CallParamType type;
     const char* msl_name;
 };
@@ -58,88 +56,88 @@
     return out;
 }
 
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
                                         CallParamType type,
                                         ProgramBuilder* builder) {
     std::string name;
     utils::StringStream str;
     str << name << builtin;
     switch (builtin) {
-        case BuiltinType::kAcos:
-        case BuiltinType::kAsin:
-        case BuiltinType::kAtan:
-        case BuiltinType::kCeil:
-        case BuiltinType::kCos:
-        case BuiltinType::kCosh:
-        case BuiltinType::kDpdx:
-        case BuiltinType::kDpdxCoarse:
-        case BuiltinType::kDpdxFine:
-        case BuiltinType::kDpdy:
-        case BuiltinType::kDpdyCoarse:
-        case BuiltinType::kDpdyFine:
-        case BuiltinType::kExp:
-        case BuiltinType::kExp2:
-        case BuiltinType::kFloor:
-        case BuiltinType::kFract:
-        case BuiltinType::kFwidth:
-        case BuiltinType::kFwidthCoarse:
-        case BuiltinType::kFwidthFine:
-        case BuiltinType::kInverseSqrt:
-        case BuiltinType::kLength:
-        case BuiltinType::kLog:
-        case BuiltinType::kLog2:
-        case BuiltinType::kNormalize:
-        case BuiltinType::kRound:
-        case BuiltinType::kSin:
-        case BuiltinType::kSinh:
-        case BuiltinType::kSqrt:
-        case BuiltinType::kTan:
-        case BuiltinType::kTanh:
-        case BuiltinType::kTrunc:
-        case BuiltinType::kSign:
+        case builtin::Function::kAcos:
+        case builtin::Function::kAsin:
+        case builtin::Function::kAtan:
+        case builtin::Function::kCeil:
+        case builtin::Function::kCos:
+        case builtin::Function::kCosh:
+        case builtin::Function::kDpdx:
+        case builtin::Function::kDpdxCoarse:
+        case builtin::Function::kDpdxFine:
+        case builtin::Function::kDpdy:
+        case builtin::Function::kDpdyCoarse:
+        case builtin::Function::kDpdyFine:
+        case builtin::Function::kExp:
+        case builtin::Function::kExp2:
+        case builtin::Function::kFloor:
+        case builtin::Function::kFract:
+        case builtin::Function::kFwidth:
+        case builtin::Function::kFwidthCoarse:
+        case builtin::Function::kFwidthFine:
+        case builtin::Function::kInverseSqrt:
+        case builtin::Function::kLength:
+        case builtin::Function::kLog:
+        case builtin::Function::kLog2:
+        case builtin::Function::kNormalize:
+        case builtin::Function::kRound:
+        case builtin::Function::kSin:
+        case builtin::Function::kSinh:
+        case builtin::Function::kSqrt:
+        case builtin::Function::kTan:
+        case builtin::Function::kTanh:
+        case builtin::Function::kTrunc:
+        case builtin::Function::kSign:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2");
             } else {
                 return builder->Call(str.str(), "f2");
             }
-        case BuiltinType::kLdexp:
+        case builtin::Function::kLdexp:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "i2");
             } else {
                 return builder->Call(str.str(), "f2", "i2");
             }
-        case BuiltinType::kAtan2:
-        case BuiltinType::kDot:
-        case BuiltinType::kDistance:
-        case BuiltinType::kPow:
-        case BuiltinType::kReflect:
-        case BuiltinType::kStep:
+        case builtin::Function::kAtan2:
+        case builtin::Function::kDot:
+        case builtin::Function::kDistance:
+        case builtin::Function::kPow:
+        case builtin::Function::kReflect:
+        case builtin::Function::kStep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2");
             }
-        case BuiltinType::kStorageBarrier:
+        case builtin::Function::kStorageBarrier:
             return builder->Call(str.str());
-        case BuiltinType::kCross:
+        case builtin::Function::kCross:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h3", "h3");
             } else {
                 return builder->Call(str.str(), "f3", "f3");
             }
-        case BuiltinType::kFma:
-        case BuiltinType::kMix:
-        case BuiltinType::kFaceForward:
-        case BuiltinType::kSmoothstep:
+        case builtin::Function::kFma:
+        case builtin::Function::kMix:
+        case builtin::Function::kFaceForward:
+        case builtin::Function::kSmoothstep:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "h2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             }
-        case BuiltinType::kAll:
-        case BuiltinType::kAny:
+        case builtin::Function::kAll:
+        case builtin::Function::kAny:
             return builder->Call(str.str(), "b2");
-        case BuiltinType::kAbs:
+        case builtin::Function::kAbs:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2");
             } else if (type == CallParamType::kF16) {
@@ -147,17 +145,17 @@
             } else {
                 return builder->Call(str.str(), "u2");
             }
-        case BuiltinType::kCountLeadingZeros:
-        case BuiltinType::kCountOneBits:
-        case BuiltinType::kCountTrailingZeros:
-        case BuiltinType::kReverseBits:
+        case builtin::Function::kCountLeadingZeros:
+        case builtin::Function::kCountOneBits:
+        case builtin::Function::kCountTrailingZeros:
+        case builtin::Function::kReverseBits:
             return builder->Call(str.str(), "u2");
-        case BuiltinType::kExtractBits:
+        case builtin::Function::kExtractBits:
             return builder->Call(str.str(), "u2", "u1", "u1");
-        case BuiltinType::kInsertBits:
+        case builtin::Function::kInsertBits:
             return builder->Call(str.str(), "u2", "u2", "u1", "u1");
-        case BuiltinType::kMax:
-        case BuiltinType::kMin:
+        case builtin::Function::kMax:
+        case builtin::Function::kMin:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -165,7 +163,7 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2");
             }
-        case BuiltinType::kClamp:
+        case builtin::Function::kClamp:
             if (type == CallParamType::kF32) {
                 return builder->Call(str.str(), "f2", "f2", "f2");
             } else if (type == CallParamType::kF16) {
@@ -173,32 +171,32 @@
             } else {
                 return builder->Call(str.str(), "u2", "u2", "u2");
             }
-        case BuiltinType::kSelect:
+        case builtin::Function::kSelect:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "h2", "h2", "b2");
             } else {
                 return builder->Call(str.str(), "f2", "f2", "b2");
             }
-        case BuiltinType::kDeterminant:
+        case builtin::Function::kDeterminant:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm2x2");
             } else {
                 return builder->Call(str.str(), "m2x2");
             }
-        case BuiltinType::kPack2X16Snorm:
-        case BuiltinType::kPack2X16Unorm:
+        case builtin::Function::kPack2X16Snorm:
+        case builtin::Function::kPack2X16Unorm:
             return builder->Call(str.str(), "f2");
-        case BuiltinType::kPack4X8Snorm:
-        case BuiltinType::kPack4X8Unorm:
+        case builtin::Function::kPack4X8Snorm:
+        case builtin::Function::kPack4X8Unorm:
             return builder->Call(str.str(), "f4");
-        case BuiltinType::kUnpack4X8Snorm:
-        case BuiltinType::kUnpack4X8Unorm:
-        case BuiltinType::kUnpack2X16Snorm:
-        case BuiltinType::kUnpack2X16Unorm:
+        case builtin::Function::kUnpack4X8Snorm:
+        case builtin::Function::kUnpack4X8Unorm:
+        case builtin::Function::kUnpack2X16Snorm:
+        case builtin::Function::kUnpack2X16Unorm:
             return builder->Call(str.str(), "u1");
-        case BuiltinType::kWorkgroupBarrier:
+        case builtin::Function::kWorkgroupBarrier:
             return builder->Call(str.str());
-        case BuiltinType::kTranspose:
+        case builtin::Function::kTranspose:
             if (type == CallParamType::kF16) {
                 return builder->Call(str.str(), "hm3x2");
             } else {
@@ -254,120 +252,126 @@
     MslBuiltinTest,
     testing::Values(
         /* Logical built-in */
-        BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
-        BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
-        BuiltinData{BuiltinType::kSelect, CallParamType::kF32, "select"},
+        BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+        BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
+        BuiltinData{builtin::Function::kSelect, CallParamType::kF32, "select"},
         /* Float built-in */
-        BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "fabs"},
-        BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "fabs"},
-        BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
-        BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
-        BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
-        BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
-        BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
-        BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
-        BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan2"},
-        BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan2"},
-        BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
-        BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
-        BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
-        BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
-        BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
-        BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
-        BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
-        BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
-        BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
-        BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
-        BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
-        BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
-        BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
-        BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
-        BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
-        BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
-        BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
-        BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
-        BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
-        BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
-        BuiltinData{BuiltinType::kFma, CallParamType::kF32, "fma"},
-        BuiltinData{BuiltinType::kFma, CallParamType::kF16, "fma"},
-        BuiltinData{BuiltinType::kFract, CallParamType::kF32, "fract"},
-        BuiltinData{BuiltinType::kFract, CallParamType::kF16, "fract"},
-        BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "rsqrt"},
-        BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "rsqrt"},
-        BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
-        BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
-        BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
-        BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
-        BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
-        BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
-        BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
-        BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
-        BuiltinData{BuiltinType::kMax, CallParamType::kF32, "fmax"},
-        BuiltinData{BuiltinType::kMax, CallParamType::kF16, "fmax"},
-        BuiltinData{BuiltinType::kMin, CallParamType::kF32, "fmin"},
-        BuiltinData{BuiltinType::kMin, CallParamType::kF16, "fmin"},
-        BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
-        BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
-        BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
-        BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
-        BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
-        BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
-        BuiltinData{BuiltinType::kSign, CallParamType::kF32, "sign"},
-        BuiltinData{BuiltinType::kSign, CallParamType::kF16, "sign"},
-        BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
-        BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
-        BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
-        BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
-        BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
-        BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
-        BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
-        BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
-        BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
-        BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
-        BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
-        BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
-        BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
-        BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
-        BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
-        BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
+        BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "fabs"},
+        BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "fabs"},
+        BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+        BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+        BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+        BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+        BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+        BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+        BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan2"},
+        BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan2"},
+        BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+        BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+        BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+        BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+        BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+        BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+        BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+        BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+        BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+        BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+        BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+        BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+        BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+        BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+        BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+        BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+        BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32, "faceforward"},
+        BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16, "faceforward"},
+        BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+        BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+        BuiltinData{builtin::Function::kFma, CallParamType::kF32, "fma"},
+        BuiltinData{builtin::Function::kFma, CallParamType::kF16, "fma"},
+        BuiltinData{builtin::Function::kFract, CallParamType::kF32, "fract"},
+        BuiltinData{builtin::Function::kFract, CallParamType::kF16, "fract"},
+        BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+        BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+        BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+        BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+        BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+        BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+        BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+        BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+        BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+        BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+        BuiltinData{builtin::Function::kMax, CallParamType::kF32, "fmax"},
+        BuiltinData{builtin::Function::kMax, CallParamType::kF16, "fmax"},
+        BuiltinData{builtin::Function::kMin, CallParamType::kF32, "fmin"},
+        BuiltinData{builtin::Function::kMin, CallParamType::kF16, "fmin"},
+        BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+        BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+        BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+        BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+        BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+        BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+        BuiltinData{builtin::Function::kSign, CallParamType::kF32, "sign"},
+        BuiltinData{builtin::Function::kSign, CallParamType::kF16, "sign"},
+        BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+        BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+        BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+        BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+        BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+        BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+        BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+        BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+        BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+        BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+        BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+        BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+        BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+        BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+        BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+        BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
         /* Integer built-in */
-        BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
-        BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
-        BuiltinData{BuiltinType::kCountLeadingZeros, CallParamType::kU32, "clz"},
-        BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "popcount"},
-        BuiltinData{BuiltinType::kCountTrailingZeros, CallParamType::kU32, "ctz"},
-        BuiltinData{BuiltinType::kExtractBits, CallParamType::kU32, "extract_bits"},
-        BuiltinData{BuiltinType::kInsertBits, CallParamType::kU32, "insert_bits"},
-        BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
-        BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
-        BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "reverse_bits"},
-        BuiltinData{BuiltinType::kRound, CallParamType::kU32, "rint"},
+        BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+        BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+        BuiltinData{builtin::Function::kCountLeadingZeros, CallParamType::kU32, "clz"},
+        BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "popcount"},
+        BuiltinData{builtin::Function::kCountTrailingZeros, CallParamType::kU32, "ctz"},
+        BuiltinData{builtin::Function::kExtractBits, CallParamType::kU32, "extract_bits"},
+        BuiltinData{builtin::Function::kInsertBits, CallParamType::kU32, "insert_bits"},
+        BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+        BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+        BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32, "reverse_bits"},
+        BuiltinData{builtin::Function::kRound, CallParamType::kU32, "rint"},
         /* Matrix built-in */
-        BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
-        BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
+        BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32, "determinant"},
+        BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
         /* Vector built-in */
-        BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
+        BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
         /* Derivate built-in */
-        BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "dfdx"},
-        BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "dfdx"},
-        BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "dfdx"},
-        BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "dfdy"},
-        BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "dfdy"},
-        BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "dfdy"},
-        BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
-        BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
-        BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"},
+        BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "dfdx"},
+        BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "dfdx"},
+        BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "dfdx"},
+        BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "dfdy"},
+        BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "dfdy"},
+        BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "dfdy"},
+        BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+        BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+        BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"},
         /* Data packing builtin */
-        BuiltinData{BuiltinType::kPack4X8Snorm, CallParamType::kF32, "pack_float_to_snorm4x8"},
-        BuiltinData{BuiltinType::kPack4X8Unorm, CallParamType::kF32, "pack_float_to_unorm4x8"},
-        BuiltinData{BuiltinType::kPack2X16Snorm, CallParamType::kF32, "pack_float_to_snorm2x16"},
-        BuiltinData{BuiltinType::kPack2X16Unorm, CallParamType::kF32, "pack_float_to_unorm2x16"},
+        BuiltinData{builtin::Function::kPack4X8Snorm, CallParamType::kF32,
+                    "pack_float_to_snorm4x8"},
+        BuiltinData{builtin::Function::kPack4X8Unorm, CallParamType::kF32,
+                    "pack_float_to_unorm4x8"},
+        BuiltinData{builtin::Function::kPack2X16Snorm, CallParamType::kF32,
+                    "pack_float_to_snorm2x16"},
+        BuiltinData{builtin::Function::kPack2X16Unorm, CallParamType::kF32,
+                    "pack_float_to_unorm2x16"},
         /* Data unpacking builtin */
-        BuiltinData{BuiltinType::kUnpack4X8Snorm, CallParamType::kU32, "unpack_snorm4x8_to_float"},
-        BuiltinData{BuiltinType::kUnpack4X8Unorm, CallParamType::kU32, "unpack_unorm4x8_to_float"},
-        BuiltinData{BuiltinType::kUnpack2X16Snorm, CallParamType::kU32,
+        BuiltinData{builtin::Function::kUnpack4X8Snorm, CallParamType::kU32,
+                    "unpack_snorm4x8_to_float"},
+        BuiltinData{builtin::Function::kUnpack4X8Unorm, CallParamType::kU32,
+                    "unpack_unorm4x8_to_float"},
+        BuiltinData{builtin::Function::kUnpack2X16Snorm, CallParamType::kU32,
                     "unpack_snorm2x16_to_float"},
-        BuiltinData{BuiltinType::kUnpack2X16Unorm, CallParamType::kU32,
+        BuiltinData{builtin::Function::kUnpack2X16Unorm, CallParamType::kU32,
                     "unpack_unorm2x16_to_float"}));
 
 TEST_F(MslGeneratorImplTest, Builtin_Call) {
diff --git a/src/tint/writer/msl/generator_impl_builtin_texture_test.cc b/src/tint/writer/msl/generator_impl_builtin_texture_test.cc
index 7beee1a..730fe99 100644
--- a/src/tint/writer/msl/generator_impl_builtin_texture_test.cc
+++ b/src/tint/writer/msl/generator_impl_builtin_texture_test.cc
@@ -90,7 +90,9 @@
         case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
             return R"(Texture.gather_compare(Sampler, float3(1.0f, 2.0f, 3.0f), 4u, 5.0f))";
         case ValidTextureOverload::kNumLayers2dArray:
+        case ValidTextureOverload::kNumLayersCubeArray:
         case ValidTextureOverload::kNumLayersDepth2dArray:
+        case ValidTextureOverload::kNumLayersDepthCubeArray:
         case ValidTextureOverload::kNumLayersStorageWO2dArray:
             return R"(Texture.get_array_size())";
         case ValidTextureOverload::kNumLevels2d:
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 40f98d8..ae14acd 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -56,8 +56,6 @@
 namespace tint::writer::spirv {
 namespace {
 
-using BuiltinType = sem::BuiltinType;
-
 const char kGLSLstd450[] = "GLSL.std.450";
 
 uint32_t size_of(const InstructionList& instructions) {
@@ -102,23 +100,23 @@
 
 uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
     switch (builtin->Type()) {
-        case BuiltinType::kAcos:
+        case builtin::Function::kAcos:
             return GLSLstd450Acos;
-        case BuiltinType::kAcosh:
+        case builtin::Function::kAcosh:
             return GLSLstd450Acosh;
-        case BuiltinType::kAsin:
+        case builtin::Function::kAsin:
             return GLSLstd450Asin;
-        case BuiltinType::kAsinh:
+        case builtin::Function::kAsinh:
             return GLSLstd450Asinh;
-        case BuiltinType::kAtan:
+        case builtin::Function::kAtan:
             return GLSLstd450Atan;
-        case BuiltinType::kAtan2:
+        case builtin::Function::kAtan2:
             return GLSLstd450Atan2;
-        case BuiltinType::kAtanh:
+        case builtin::Function::kAtanh:
             return GLSLstd450Atanh;
-        case BuiltinType::kCeil:
+        case builtin::Function::kCeil:
             return GLSLstd450Ceil;
-        case BuiltinType::kClamp:
+        case builtin::Function::kClamp:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 return GLSLstd450NClamp;
             } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -126,43 +124,43 @@
             } else {
                 return GLSLstd450SClamp;
             }
-        case BuiltinType::kCos:
+        case builtin::Function::kCos:
             return GLSLstd450Cos;
-        case BuiltinType::kCosh:
+        case builtin::Function::kCosh:
             return GLSLstd450Cosh;
-        case BuiltinType::kCross:
+        case builtin::Function::kCross:
             return GLSLstd450Cross;
-        case BuiltinType::kDegrees:
+        case builtin::Function::kDegrees:
             return GLSLstd450Degrees;
-        case BuiltinType::kDeterminant:
+        case builtin::Function::kDeterminant:
             return GLSLstd450Determinant;
-        case BuiltinType::kDistance:
+        case builtin::Function::kDistance:
             return GLSLstd450Distance;
-        case BuiltinType::kExp:
+        case builtin::Function::kExp:
             return GLSLstd450Exp;
-        case BuiltinType::kExp2:
+        case builtin::Function::kExp2:
             return GLSLstd450Exp2;
-        case BuiltinType::kFaceForward:
+        case builtin::Function::kFaceForward:
             return GLSLstd450FaceForward;
-        case BuiltinType::kFloor:
+        case builtin::Function::kFloor:
             return GLSLstd450Floor;
-        case BuiltinType::kFma:
+        case builtin::Function::kFma:
             return GLSLstd450Fma;
-        case BuiltinType::kFract:
+        case builtin::Function::kFract:
             return GLSLstd450Fract;
-        case BuiltinType::kFrexp:
+        case builtin::Function::kFrexp:
             return GLSLstd450FrexpStruct;
-        case BuiltinType::kInverseSqrt:
+        case builtin::Function::kInverseSqrt:
             return GLSLstd450InverseSqrt;
-        case BuiltinType::kLdexp:
+        case builtin::Function::kLdexp:
             return GLSLstd450Ldexp;
-        case BuiltinType::kLength:
+        case builtin::Function::kLength:
             return GLSLstd450Length;
-        case BuiltinType::kLog:
+        case builtin::Function::kLog:
             return GLSLstd450Log;
-        case BuiltinType::kLog2:
+        case builtin::Function::kLog2:
             return GLSLstd450Log2;
-        case BuiltinType::kMax:
+        case builtin::Function::kMax:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 return GLSLstd450NMax;
             } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -170,7 +168,7 @@
             } else {
                 return GLSLstd450SMax;
             }
-        case BuiltinType::kMin:
+        case builtin::Function::kMin:
             if (builtin->ReturnType()->is_float_scalar_or_vector()) {
                 return GLSLstd450NMin;
             } else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -178,63 +176,63 @@
             } else {
                 return GLSLstd450SMin;
             }
-        case BuiltinType::kMix:
+        case builtin::Function::kMix:
             return GLSLstd450FMix;
-        case BuiltinType::kModf:
+        case builtin::Function::kModf:
             return GLSLstd450ModfStruct;
-        case BuiltinType::kNormalize:
+        case builtin::Function::kNormalize:
             return GLSLstd450Normalize;
-        case BuiltinType::kPack4X8Snorm:
+        case builtin::Function::kPack4X8Snorm:
             return GLSLstd450PackSnorm4x8;
-        case BuiltinType::kPack4X8Unorm:
+        case builtin::Function::kPack4X8Unorm:
             return GLSLstd450PackUnorm4x8;
-        case BuiltinType::kPack2X16Snorm:
+        case builtin::Function::kPack2X16Snorm:
             return GLSLstd450PackSnorm2x16;
-        case BuiltinType::kPack2X16Unorm:
+        case builtin::Function::kPack2X16Unorm:
             return GLSLstd450PackUnorm2x16;
-        case BuiltinType::kPack2X16Float:
+        case builtin::Function::kPack2X16Float:
             return GLSLstd450PackHalf2x16;
-        case BuiltinType::kPow:
+        case builtin::Function::kPow:
             return GLSLstd450Pow;
-        case BuiltinType::kRadians:
+        case builtin::Function::kRadians:
             return GLSLstd450Radians;
-        case BuiltinType::kReflect:
+        case builtin::Function::kReflect:
             return GLSLstd450Reflect;
-        case BuiltinType::kRefract:
+        case builtin::Function::kRefract:
             return GLSLstd450Refract;
-        case BuiltinType::kRound:
+        case builtin::Function::kRound:
             return GLSLstd450RoundEven;
-        case BuiltinType::kSign:
+        case builtin::Function::kSign:
             if (builtin->ReturnType()->is_signed_integer_scalar_or_vector()) {
                 return GLSLstd450SSign;
             } else {
                 return GLSLstd450FSign;
             }
-        case BuiltinType::kSin:
+        case builtin::Function::kSin:
             return GLSLstd450Sin;
-        case BuiltinType::kSinh:
+        case builtin::Function::kSinh:
             return GLSLstd450Sinh;
-        case BuiltinType::kSmoothstep:
+        case builtin::Function::kSmoothstep:
             return GLSLstd450SmoothStep;
-        case BuiltinType::kSqrt:
+        case builtin::Function::kSqrt:
             return GLSLstd450Sqrt;
-        case BuiltinType::kStep:
+        case builtin::Function::kStep:
             return GLSLstd450Step;
-        case BuiltinType::kTan:
+        case builtin::Function::kTan:
             return GLSLstd450Tan;
-        case BuiltinType::kTanh:
+        case builtin::Function::kTanh:
             return GLSLstd450Tanh;
-        case BuiltinType::kTrunc:
+        case builtin::Function::kTrunc:
             return GLSLstd450Trunc;
-        case BuiltinType::kUnpack4X8Snorm:
+        case builtin::Function::kUnpack4X8Snorm:
             return GLSLstd450UnpackSnorm4x8;
-        case BuiltinType::kUnpack4X8Unorm:
+        case builtin::Function::kUnpack4X8Unorm:
             return GLSLstd450UnpackUnorm4x8;
-        case BuiltinType::kUnpack2X16Snorm:
+        case builtin::Function::kUnpack2X16Snorm:
             return GLSLstd450UnpackSnorm2x16;
-        case BuiltinType::kUnpack2X16Unorm:
+        case builtin::Function::kUnpack2X16Unorm:
             return GLSLstd450UnpackUnorm2x16;
-        case BuiltinType::kUnpack2X16Float:
+        case builtin::Function::kUnpack2X16Float:
             return GLSLstd450UnpackHalf2x16;
         default:
             break;
@@ -2363,21 +2361,21 @@
     };
 
     switch (builtin->Type()) {
-        case BuiltinType::kAny:
+        case builtin::Function::kAny:
             if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
                 // any(v: bool) just resolves to v.
                 return get_arg_as_value_id(0);
             }
             op = spv::Op::OpAny;
             break;
-        case BuiltinType::kAll:
+        case builtin::Function::kAll:
             if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
                 // all(v: bool) just resolves to v.
                 return get_arg_as_value_id(0);
             }
             op = spv::Op::OpAll;
             break;
-        case BuiltinType::kArrayLength: {
+        case builtin::Function::kArrayLength: {
             auto* address_of = call->Arguments()[0]->Declaration()->As<ast::UnaryOpExpression>();
             if (!address_of || address_of->op != ast::UnaryOp::kAddressOf) {
                 error_ = "arrayLength() expected pointer to member access, got " +
@@ -2414,10 +2412,10 @@
             }
             return result_id;
         }
-        case BuiltinType::kCountOneBits:
+        case builtin::Function::kCountOneBits:
             op = spv::Op::OpBitCount;
             break;
-        case BuiltinType::kDot: {
+        case builtin::Function::kDot: {
             op = spv::Op::OpDot;
             auto* vec_ty = builtin->Parameters()[0]->Type()->As<type::Vector>();
             if (vec_ty->type()->is_integer_scalar()) {
@@ -2458,42 +2456,42 @@
             }
             break;
         }
-        case BuiltinType::kDpdx:
+        case builtin::Function::kDpdx:
             op = spv::Op::OpDPdx;
             break;
-        case BuiltinType::kDpdxCoarse:
+        case builtin::Function::kDpdxCoarse:
             op = spv::Op::OpDPdxCoarse;
             break;
-        case BuiltinType::kDpdxFine:
+        case builtin::Function::kDpdxFine:
             op = spv::Op::OpDPdxFine;
             break;
-        case BuiltinType::kDpdy:
+        case builtin::Function::kDpdy:
             op = spv::Op::OpDPdy;
             break;
-        case BuiltinType::kDpdyCoarse:
+        case builtin::Function::kDpdyCoarse:
             op = spv::Op::OpDPdyCoarse;
             break;
-        case BuiltinType::kDpdyFine:
+        case builtin::Function::kDpdyFine:
             op = spv::Op::OpDPdyFine;
             break;
-        case BuiltinType::kExtractBits:
+        case builtin::Function::kExtractBits:
             op = builtin->Parameters()[0]->Type()->is_unsigned_integer_scalar_or_vector()
                      ? spv::Op::OpBitFieldUExtract
                      : spv::Op::OpBitFieldSExtract;
             break;
-        case BuiltinType::kFwidth:
+        case builtin::Function::kFwidth:
             op = spv::Op::OpFwidth;
             break;
-        case BuiltinType::kFwidthCoarse:
+        case builtin::Function::kFwidthCoarse:
             op = spv::Op::OpFwidthCoarse;
             break;
-        case BuiltinType::kFwidthFine:
+        case builtin::Function::kFwidthFine:
             op = spv::Op::OpFwidthFine;
             break;
-        case BuiltinType::kInsertBits:
+        case builtin::Function::kInsertBits:
             op = spv::Op::OpBitFieldInsert;
             break;
-        case BuiltinType::kMix: {
+        case builtin::Function::kMix: {
             auto std450 = Operand(GetGLSLstd450Import());
 
             auto a_id = get_arg_as_value_id(0);
@@ -2520,13 +2518,13 @@
             }
             return result_id;
         }
-        case BuiltinType::kQuantizeToF16:
+        case builtin::Function::kQuantizeToF16:
             op = spv::Op::OpQuantizeToF16;
             break;
-        case BuiltinType::kReverseBits:
+        case builtin::Function::kReverseBits:
             op = spv::Op::OpBitReverse;
             break;
-        case BuiltinType::kSelect: {
+        case builtin::Function::kSelect: {
             // Note: Argument order is different in WGSL and SPIR-V
             auto cond_id = get_arg_as_value_id(2);
             auto true_id = get_arg_as_value_id(1);
@@ -2558,10 +2556,10 @@
             }
             return result_id;
         }
-        case BuiltinType::kTranspose:
+        case builtin::Function::kTranspose:
             op = spv::Op::OpTranspose;
             break;
-        case BuiltinType::kAbs:
+        case builtin::Function::kAbs:
             if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
                 // abs() only operates on *signed* integers.
                 // This is a no-op for unsigned integers.
@@ -2573,7 +2571,7 @@
                 glsl_std450(GLSLstd450SAbs);
             }
             break;
-        case BuiltinType::kDot4I8Packed: {
+        case builtin::Function::kDot4I8Packed: {
             auto first_param_id = get_arg_as_value_id(0);
             auto second_param_id = get_arg_as_value_id(1);
             if (!push_function_inst(spv::Op::OpSDotKHR,
@@ -2585,7 +2583,7 @@
             }
             return result_id;
         }
-        case BuiltinType::kDot4U8Packed: {
+        case builtin::Function::kDot4U8Packed: {
             auto first_param_id = get_arg_as_value_id(0);
             auto second_param_id = get_arg_as_value_id(1);
             if (!push_function_inst(spv::Op::OpUDotKHR,
@@ -2788,7 +2786,7 @@
     };
 
     switch (builtin->Type()) {
-        case BuiltinType::kTextureDimensions: {
+        case builtin::Function::kTextureDimensions: {
             // Number of returned elements from OpImageQuerySize[Lod] may not match
             // those of textureDimensions().
             // This might be due to an extra vector scalar describing the number of
@@ -2833,7 +2831,7 @@
             }
             break;
         }
-        case BuiltinType::kTextureNumLayers: {
+        case builtin::Function::kTextureNumLayers: {
             uint32_t spirv_dims = 0;
             switch (texture_type->dim()) {
                 default:
@@ -2863,19 +2861,19 @@
             }
             break;
         }
-        case BuiltinType::kTextureNumLevels: {
+        case builtin::Function::kTextureNumLevels: {
             op = spv::Op::OpImageQueryLevels;
             append_result_type_and_id_to_spirv_params();
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
             break;
         }
-        case BuiltinType::kTextureNumSamples: {
+        case builtin::Function::kTextureNumSamples: {
             op = spv::Op::OpImageQuerySamples;
             append_result_type_and_id_to_spirv_params();
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
             break;
         }
-        case BuiltinType::kTextureLoad: {
+        case builtin::Function::kTextureLoad: {
             op = texture_type->Is<type::StorageTexture>() ? spv::Op::OpImageRead
                                                           : spv::Op::OpImageFetch;
             append_result_type_and_id_to_spirv_params_for_read();
@@ -2895,7 +2893,7 @@
 
             break;
         }
-        case BuiltinType::kTextureStore: {
+        case builtin::Function::kTextureStore: {
             op = spv::Op::OpImageWrite;
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
             if (!append_coords_to_spirv_params()) {
@@ -2904,7 +2902,7 @@
             spirv_params.emplace_back(gen_arg(Usage::kValue));
             break;
         }
-        case BuiltinType::kTextureGather: {
+        case builtin::Function::kTextureGather: {
             op = spv::Op::OpImageGather;
             append_result_type_and_id_to_spirv_params();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2918,7 +2916,7 @@
             }
             break;
         }
-        case BuiltinType::kTextureGatherCompare: {
+        case builtin::Function::kTextureGatherCompare: {
             op = spv::Op::OpImageDrefGather;
             append_result_type_and_id_to_spirv_params();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2927,7 +2925,7 @@
             spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
             break;
         }
-        case BuiltinType::kTextureSample: {
+        case builtin::Function::kTextureSample: {
             op = spv::Op::OpImageSampleImplicitLod;
             append_result_type_and_id_to_spirv_params_for_read();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2935,7 +2933,7 @@
             }
             break;
         }
-        case BuiltinType::kTextureSampleBias: {
+        case builtin::Function::kTextureSampleBias: {
             op = spv::Op::OpImageSampleImplicitLod;
             append_result_type_and_id_to_spirv_params_for_read();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2945,7 +2943,7 @@
                 ImageOperand{SpvImageOperandsBiasMask, gen_arg(Usage::kBias)});
             break;
         }
-        case BuiltinType::kTextureSampleLevel: {
+        case builtin::Function::kTextureSampleLevel: {
             op = spv::Op::OpImageSampleExplicitLod;
             append_result_type_and_id_to_spirv_params_for_read();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2970,7 +2968,7 @@
             image_operands.emplace_back(ImageOperand{SpvImageOperandsLodMask, level});
             break;
         }
-        case BuiltinType::kTextureSampleGrad: {
+        case builtin::Function::kTextureSampleGrad: {
             op = spv::Op::OpImageSampleExplicitLod;
             append_result_type_and_id_to_spirv_params_for_read();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2982,7 +2980,7 @@
                 ImageOperand{SpvImageOperandsGradMask, gen_arg(Usage::kDdy)});
             break;
         }
-        case BuiltinType::kTextureSampleCompare: {
+        case builtin::Function::kTextureSampleCompare: {
             op = spv::Op::OpImageSampleDrefImplicitLod;
             append_result_type_and_id_to_spirv_params();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -2991,7 +2989,7 @@
             spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
             break;
         }
-        case BuiltinType::kTextureSampleCompareLevel: {
+        case builtin::Function::kTextureSampleCompareLevel: {
             op = spv::Op::OpImageSampleDrefExplicitLod;
             append_result_type_and_id_to_spirv_params();
             if (!append_image_and_coords_to_spirv_params()) {
@@ -3046,19 +3044,19 @@
 
     // TODO(crbug.com/tint/661): Combine sequential barriers to a single
     // instruction.
-    if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+    if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
         execution = static_cast<uint32_t>(spv::Scope::Workgroup);
         memory = static_cast<uint32_t>(spv::Scope::Workgroup);
         semantics = static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
                     static_cast<uint32_t>(spv::MemorySemanticsMask::WorkgroupMemory);
-    } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+    } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
         execution = static_cast<uint32_t>(spv::Scope::Workgroup);
         memory = static_cast<uint32_t>(spv::Scope::Workgroup);
         semantics = static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
                     static_cast<uint32_t>(spv::MemorySemanticsMask::UniformMemory);
     } else {
         error_ = "unexpected barrier builtin type ";
-        error_ += sem::str(builtin->Type());
+        error_ += builtin::str(builtin->Type());
         return false;
     }
 
@@ -3128,7 +3126,7 @@
     Operand semantics = Operand(semantics_id);
 
     switch (builtin->Type()) {
-        case sem::BuiltinType::kAtomicLoad:
+        case builtin::Function::kAtomicLoad:
             return push_function_inst(spv::Op::OpAtomicLoad, {
                                                                  result_type,
                                                                  result_id,
@@ -3136,14 +3134,14 @@
                                                                  memory,
                                                                  semantics,
                                                              });
-        case sem::BuiltinType::kAtomicStore:
+        case builtin::Function::kAtomicStore:
             return push_function_inst(spv::Op::OpAtomicStore, {
                                                                   pointer,
                                                                   memory,
                                                                   semantics,
                                                                   value,
                                                               });
-        case sem::BuiltinType::kAtomicAdd:
+        case builtin::Function::kAtomicAdd:
             return push_function_inst(spv::Op::OpAtomicIAdd, {
                                                                  result_type,
                                                                  result_id,
@@ -3152,7 +3150,7 @@
                                                                  semantics,
                                                                  value,
                                                              });
-        case sem::BuiltinType::kAtomicSub:
+        case builtin::Function::kAtomicSub:
             return push_function_inst(spv::Op::OpAtomicISub, {
                                                                  result_type,
                                                                  result_id,
@@ -3161,7 +3159,7 @@
                                                                  semantics,
                                                                  value,
                                                              });
-        case sem::BuiltinType::kAtomicMax:
+        case builtin::Function::kAtomicMax:
             return push_function_inst(
                 is_value_signed() ? spv::Op::OpAtomicSMax : spv::Op::OpAtomicUMax, {
                                                                                        result_type,
@@ -3171,7 +3169,7 @@
                                                                                        semantics,
                                                                                        value,
                                                                                    });
-        case sem::BuiltinType::kAtomicMin:
+        case builtin::Function::kAtomicMin:
             return push_function_inst(
                 is_value_signed() ? spv::Op::OpAtomicSMin : spv::Op::OpAtomicUMin, {
                                                                                        result_type,
@@ -3181,7 +3179,7 @@
                                                                                        semantics,
                                                                                        value,
                                                                                    });
-        case sem::BuiltinType::kAtomicAnd:
+        case builtin::Function::kAtomicAnd:
             return push_function_inst(spv::Op::OpAtomicAnd, {
                                                                 result_type,
                                                                 result_id,
@@ -3190,7 +3188,7 @@
                                                                 semantics,
                                                                 value,
                                                             });
-        case sem::BuiltinType::kAtomicOr:
+        case builtin::Function::kAtomicOr:
             return push_function_inst(spv::Op::OpAtomicOr, {
                                                                result_type,
                                                                result_id,
@@ -3199,7 +3197,7 @@
                                                                semantics,
                                                                value,
                                                            });
-        case sem::BuiltinType::kAtomicXor:
+        case builtin::Function::kAtomicXor:
             return push_function_inst(spv::Op::OpAtomicXor, {
                                                                 result_type,
                                                                 result_id,
@@ -3208,7 +3206,7 @@
                                                                 semantics,
                                                                 value,
                                                             });
-        case sem::BuiltinType::kAtomicExchange:
+        case builtin::Function::kAtomicExchange:
             return push_function_inst(spv::Op::OpAtomicExchange, {
                                                                      result_type,
                                                                      result_id,
@@ -3217,7 +3215,7 @@
                                                                      semantics,
                                                                      value,
                                                                  });
-        case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+        case builtin::Function::kAtomicCompareExchangeWeak: {
             auto comparator = GenerateExpression(call->Arguments()[1]);
             if (comparator == 0) {
                 return false;
diff --git a/src/tint/writer/spirv/builder_builtin_test.cc b/src/tint/writer/spirv/builder_builtin_test.cc
index 5db867a..280b878 100644
--- a/src/tint/writer/spirv/builder_builtin_test.cc
+++ b/src/tint/writer/spirv/builder_builtin_test.cc
@@ -4154,10 +4154,7 @@
 namespace DP4A_builtin_tests {
 
 TEST_F(BuiltinBuilderTest, Call_Dot4I8Packed) {
-    auto* ext =
-        create<ast::Enable>(Source{Source::Range{Source::Location{10, 2}, Source::Location{10, 5}}},
-                            builtin::Extension::kChromiumExperimentalDp4A);
-    AST().AddEnable(ext);
+    Enable(builtin::Extension::kChromiumExperimentalDp4A);
 
     auto* val1 = Var("val1", ty.u32());
     auto* val2 = Var("val2", ty.u32());
@@ -4194,10 +4191,7 @@
 }
 
 TEST_F(BuiltinBuilderTest, Call_Dot4U8Packed) {
-    auto* ext =
-        create<ast::Enable>(Source{Source::Range{Source::Location{10, 2}, Source::Location{10, 5}}},
-                            builtin::Extension::kChromiumExperimentalDp4A);
-    AST().AddEnable(ext);
+    Enable(builtin::Extension::kChromiumExperimentalDp4A);
 
     auto* val1 = Var("val1", ty.u32());
     auto* val2 = Var("val2", ty.u32());
diff --git a/src/tint/writer/spirv/builder_builtin_texture_test.cc b/src/tint/writer/spirv/builder_builtin_texture_test.cc
index 766b78b..4697582 100644
--- a/src/tint/writer/spirv/builder_builtin_texture_test.cc
+++ b/src/tint/writer/spirv/builder_builtin_texture_test.cc
@@ -1132,6 +1132,29 @@
                     R"(
 OpCapability ImageQuery
 )"};
+        case ValidTextureOverload::kNumLayersCubeArray:
+            return {R"(
+%4 = OpTypeFloat 32
+%3 = OpTypeImage %4 Cube 0 1 0 1 Unknown
+%2 = OpTypePointer UniformConstant %3
+%1 = OpVariable %2 UniformConstant
+%7 = OpTypeSampler
+%6 = OpTypePointer UniformConstant %7
+%5 = OpVariable %6 UniformConstant
+%9 = OpTypeInt 32 0
+%11 = OpTypeVector %9 3
+%13 = OpTypeInt 32 1
+%14 = OpConstant %13 0
+)",
+                    R"(
+%12 = OpLoad %3 %1
+%10 = OpImageQuerySizeLod %11 %12 %14
+%8 = OpCompositeExtract %9 %10 2
+)",
+                    R"(
+OpCapability SampledCubeArray
+OpCapability ImageQuery
+)"};
         case ValidTextureOverload::kNumLayersDepth2dArray:
             return {R"(
 %4 = OpTypeFloat 32
@@ -1154,6 +1177,29 @@
                     R"(
 OpCapability ImageQuery
 )"};
+        case ValidTextureOverload::kNumLayersDepthCubeArray:
+            return {R"(
+%4 = OpTypeFloat 32
+%3 = OpTypeImage %4 Cube 0 1 0 1 Unknown
+%2 = OpTypePointer UniformConstant %3
+%1 = OpVariable %2 UniformConstant
+%7 = OpTypeSampler
+%6 = OpTypePointer UniformConstant %7
+%5 = OpVariable %6 UniformConstant
+%9 = OpTypeInt 32 0
+%11 = OpTypeVector %9 3
+%13 = OpTypeInt 32 1
+%14 = OpConstant %13 0
+)",
+                    R"(
+%12 = OpLoad %3 %1
+%10 = OpImageQuerySizeLod %11 %12 %14
+%8 = OpCompositeExtract %9 %10 2
+)",
+                    R"(
+OpCapability SampledCubeArray
+OpCapability ImageQuery
+)"};
         case ValidTextureOverload::kNumLayersStorageWO2dArray:
             return {R"(
 %4 = OpTypeFloat 32
diff --git a/src/tint/writer/spirv/generator.h b/src/tint/writer/spirv/generator.h
index 8b34032..f6d2268 100644
--- a/src/tint/writer/spirv/generator.h
+++ b/src/tint/writer/spirv/generator.h
@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "src/tint/reflection.h"
+#include "src/tint/writer/external_texture_options.h"
 #include "src/tint/writer/writer.h"
 
 // Forward declarations
@@ -45,8 +46,11 @@
     /// Set to `true` to disable workgroup memory zero initialization
     bool disable_workgroup_init = false;
 
-    /// Set to 'true' to generates binding mappings for external textures
-    bool generate_external_texture_bindings = false;
+    /// Set to `true` to clamp frag depth
+    bool clamp_frag_depth = false;
+
+    /// Options used in the binding mappings for external textures
+    ExternalTextureOptions external_texture_options = {};
 
     /// Set to `true` to initialize workgroup memory with OpConstantNull when
     /// VK_KHR_zero_initialize_workgroup_memory is enabled.
@@ -56,7 +60,7 @@
     TINT_REFLECT(disable_robustness,
                  emit_vertex_point_size,
                  disable_workgroup_init,
-                 generate_external_texture_bindings,
+                 external_texture_options,
                  use_zero_initialize_workgroup_memory_extension);
 };
 
diff --git a/src/tint/writer/spirv/generator_impl.cc b/src/tint/writer/spirv/generator_impl.cc
index 72a3629..1986f83 100644
--- a/src/tint/writer/spirv/generator_impl.cc
+++ b/src/tint/writer/spirv/generator_impl.cc
@@ -21,6 +21,7 @@
 #include "src/tint/transform/add_empty_entry_point.h"
 #include "src/tint/transform/builtin_polyfill.h"
 #include "src/tint/transform/canonicalize_entry_point_io.h"
+#include "src/tint/transform/clamp_frag_depth.h"
 #include "src/tint/transform/demote_to_helper.h"
 #include "src/tint/transform/direct_variable_access.h"
 #include "src/tint/transform/disable_uniformity_analysis.h"
@@ -28,6 +29,7 @@
 #include "src/tint/transform/for_loop_to_loop.h"
 #include "src/tint/transform/manager.h"
 #include "src/tint/transform/merge_return.h"
+#include "src/tint/transform/multiplanar_external_texture.h"
 #include "src/tint/transform/preserve_padding.h"
 #include "src/tint/transform/promote_side_effects_to_decl.h"
 #include "src/tint/transform/remove_phonies.h"
@@ -41,7 +43,6 @@
 #include "src/tint/transform/vectorize_scalar_matrix_initializers.h"
 #include "src/tint/transform/while_to_loop.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
-#include "src/tint/writer/generate_external_texture_bindings.h"
 
 namespace tint::writer::spirv {
 
@@ -49,6 +50,10 @@
     transform::Manager manager;
     transform::DataMap data;
 
+    if (options.clamp_frag_depth) {
+        manager.Add<tint::transform::ClampFragDepth>();
+    }
+
     manager.Add<transform::DisableUniformityAnalysis>();
 
     // ExpandCompoundAssignment must come before BuiltinPolyfill
@@ -73,10 +78,10 @@
         manager.Add<transform::Robustness>();
     }
 
-    if (options.generate_external_texture_bindings) {
+    if (!options.external_texture_options.bindings_map.empty()) {
         // Note: it is more efficient for MultiplanarExternalTexture to come after Robustness
-        auto new_bindings_map = GenerateExternalTextureBindings(in);
-        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(new_bindings_map);
+        data.Add<transform::MultiplanarExternalTexture::NewBindingPoints>(
+            options.external_texture_options.bindings_map);
         manager.Add<transform::MultiplanarExternalTexture>();
     }
 
@@ -89,6 +94,7 @@
         polyfills.bgra8unorm = true;
         polyfills.bitshift_modulo = true;
         polyfills.clamp_int = true;
+        polyfills.conv_f32_to_iu32 = true;
         polyfills.count_leading_zeros = true;
         polyfills.count_trailing_zeros = true;
         polyfills.extract_bits = transform::BuiltinPolyfill::Level::kClampParameters;
diff --git a/src/tint/writer/syntax_tree/generator.cc b/src/tint/writer/syntax_tree/generator.cc
new file mode 100644
index 0000000..6919d24
--- /dev/null
+++ b/src/tint/writer/syntax_tree/generator.cc
@@ -0,0 +1,36 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/writer/syntax_tree/generator.h"
+#include "src/tint/writer/syntax_tree/generator_impl.h"
+
+namespace tint::writer::syntax_tree {
+
+Result::Result() = default;
+Result::~Result() = default;
+Result::Result(const Result&) = default;
+
+Result Generate(const Program* program, const Options&) {
+    Result result;
+
+    // Generate the AST dump.
+    auto impl = std::make_unique<GeneratorImpl>(program);
+    result.success = impl->Generate();
+    result.error = impl->error();
+    result.ast = impl->result();
+
+    return result;
+}
+
+}  // namespace tint::writer::syntax_tree
diff --git a/src/tint/writer/syntax_tree/generator.h b/src/tint/writer/syntax_tree/generator.h
new file mode 100644
index 0000000..ce81c3f
--- /dev/null
+++ b/src/tint/writer/syntax_tree/generator.h
@@ -0,0 +1,65 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_
+#define SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_
+
+#include <memory>
+#include <string>
+
+#include "src/tint/writer/text.h"
+
+// Forward declarations
+namespace tint {
+class Program;
+}  // namespace tint
+
+namespace tint::writer::syntax_tree {
+
+class GeneratorImpl;
+
+/// Configuration options used for generating AST.
+struct Options {};
+
+/// The result produced when generating AST.
+struct Result {
+    /// Constructor
+    Result();
+
+    /// Destructor
+    ~Result();
+
+    /// Copy constructor
+    Result(const Result&);
+
+    /// True if generation was successful.
+    bool success = false;
+
+    /// The errors generated during code generation, if any.
+    std::string error;
+
+    /// The generated AST.
+    std::string ast = "";
+};
+
+/// Generate an AST dump for a program, according to a set of configuration options.
+/// The result will contain the AST, as well as success status and diagnostic information.
+/// @param program the program to dump
+/// @param options the configuration options to use when dumping
+/// @returns the resulting AST dump and supplementary information
+Result Generate(const Program* program, const Options& options);
+
+}  // namespace tint::writer::syntax_tree
+
+#endif  // SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_
diff --git a/src/tint/writer/syntax_tree/generator_impl.cc b/src/tint/writer/syntax_tree/generator_impl.cc
new file mode 100644
index 0000000..02e6ff7
--- /dev/null
+++ b/src/tint/writer/syntax_tree/generator_impl.cc
@@ -0,0 +1,1358 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/writer/syntax_tree/generator_impl.h"
+
+#include <algorithm>
+
+#include "src/tint/ast/alias.h"
+#include "src/tint/ast/bool_literal_expression.h"
+#include "src/tint/ast/call_statement.h"
+#include "src/tint/ast/float_literal_expression.h"
+#include "src/tint/ast/id_attribute.h"
+#include "src/tint/ast/internal_attribute.h"
+#include "src/tint/ast/interpolate_attribute.h"
+#include "src/tint/ast/invariant_attribute.h"
+#include "src/tint/ast/module.h"
+#include "src/tint/ast/stage_attribute.h"
+#include "src/tint/ast/stride_attribute.h"
+#include "src/tint/ast/struct_member_align_attribute.h"
+#include "src/tint/ast/struct_member_offset_attribute.h"
+#include "src/tint/ast/struct_member_size_attribute.h"
+#include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/ast/workgroup_attribute.h"
+#include "src/tint/sem/struct.h"
+#include "src/tint/sem/switch_statement.h"
+#include "src/tint/switch.h"
+#include "src/tint/utils/math.h"
+#include "src/tint/utils/scoped_assignment.h"
+#include "src/tint/writer/float_to_string.h"
+
+namespace tint::writer::syntax_tree {
+
+GeneratorImpl::GeneratorImpl(const Program* program) : TextGenerator(program) {}
+
+GeneratorImpl::~GeneratorImpl() = default;
+
+bool GeneratorImpl::Generate() {
+    // Generate global declarations in the order they appear in the module.
+    for (auto* decl : program_->AST().GlobalDeclarations()) {
+        if (!Switch(
+                decl,  //
+                [&](const ast::DiagnosticDirective* dd) {
+                    return EmitDiagnosticControl(dd->control);
+                },
+                [&](const ast::Enable* e) { return EmitEnable(e); },
+                [&](const ast::TypeDecl* td) { return EmitTypeDecl(td); },
+                [&](const ast::Function* func) { return EmitFunction(func); },
+                [&](const ast::Variable* var) { return EmitVariable(var); },
+                [&](const ast::ConstAssert* ca) { return EmitConstAssert(ca); },
+                [&](Default) {
+                    TINT_UNREACHABLE(Writer, diagnostics_);
+                    return false;
+                })) {
+            return false;
+        }
+        if (decl != program_->AST().GlobalDeclarations().Back()) {
+            line();
+        }
+    }
+
+    return true;
+}
+
+bool GeneratorImpl::EmitDiagnosticControl(const ast::DiagnosticControl& diagnostic) {
+    line() << "DiagnosticControl [severity: " << diagnostic.severity
+           << ", rule: " << program_->Symbols().NameFor(diagnostic.rule_name->symbol) << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitEnable(const ast::Enable* enable) {
+    auto l = line();
+    l << "Enable [";
+    for (auto* ext : enable->extensions) {
+        if (ext != enable->extensions.Front()) {
+            l << ", ";
+        }
+        l << ext->name;
+    }
+    l << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitTypeDecl(const ast::TypeDecl* ty) {
+    return Switch(
+        ty,
+        [&](const ast::Alias* alias) {  //
+            line() << "Alias [";
+            {
+                ScopedIndent ai(this);
+
+                line() << "name: " << program_->Symbols().NameFor(alias->name->symbol);
+                line() << "expr: ";
+                {
+                    ScopedIndent ex(this);
+                    if (!EmitExpression(alias->type)) {
+                        return false;
+                    }
+                }
+            }
+            line() << "]";
+            return true;
+        },
+        [&](const ast::Struct* str) {  //
+            return EmitStructType(str);
+        },
+        [&](Default) {  //
+            diagnostics_.add_error(diag::System::Writer,
+                                   "unknown declared type: " + std::string(ty->TypeInfo().name));
+            return false;
+        });
+}
+
+bool GeneratorImpl::EmitExpression(const ast::Expression* expr) {
+    return Switch(
+        expr,
+        [&](const ast::IndexAccessorExpression* a) {  //
+            return EmitIndexAccessor(a);
+        },
+        [&](const ast::BinaryExpression* b) {  //
+            return EmitBinary(b);
+        },
+        [&](const ast::BitcastExpression* b) {  //
+            return EmitBitcast(b);
+        },
+        [&](const ast::CallExpression* c) {  //
+            return EmitCall(c);
+        },
+        [&](const ast::IdentifierExpression* i) {  //
+            return EmitIdentifier(i);
+        },
+        [&](const ast::LiteralExpression* l) {  //
+            return EmitLiteral(l);
+        },
+        [&](const ast::MemberAccessorExpression* m) {  //
+            return EmitMemberAccessor(m);
+        },
+        [&](const ast::PhonyExpression*) {  //
+            line() << "[PhonyExpression]";
+            return true;
+        },
+        [&](const ast::UnaryOpExpression* u) {  //
+            return EmitUnaryOp(u);
+        },
+        [&](Default) {
+            diagnostics_.add_error(diag::System::Writer, "unknown expression type");
+            return false;
+        });
+}
+
+bool GeneratorImpl::EmitIndexAccessor(const ast::IndexAccessorExpression* expr) {
+    line() << "IndexAccessorExpression [";
+    {
+        ScopedIndent iae(this);
+        line() << "object: ";
+        {
+            ScopedIndent obj(this);
+            if (!EmitExpression(expr->object)) {
+                return false;
+            }
+        }
+
+        line() << "index: ";
+        {
+            ScopedIndent idx(this);
+            if (!EmitExpression(expr->index)) {
+                return false;
+            }
+        }
+    }
+    line() << "]";
+
+    return true;
+}
+
+bool GeneratorImpl::EmitMemberAccessor(const ast::MemberAccessorExpression* expr) {
+    line() << "MemberAccessorExpression [";
+    {
+        ScopedIndent mae(this);
+
+        line() << "object: ";
+        {
+            ScopedIndent obj(this);
+            if (!EmitExpression(expr->object)) {
+                return false;
+            }
+        }
+        line() << "member: " << program_->Symbols().NameFor(expr->member->symbol);
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitBitcast(const ast::BitcastExpression* expr) {
+    line() << "BitcastExpression [";
+    {
+        ScopedIndent bc(this);
+        {
+            line() << "type: ";
+            ScopedIndent ty(this);
+            if (!EmitExpression(expr->type)) {
+                return false;
+            }
+        }
+        {
+            line() << "expr: ";
+            ScopedIndent exp(this);
+            if (!EmitExpression(expr->expr)) {
+                return false;
+            }
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitCall(const ast::CallExpression* expr) {
+    line() << "Call [";
+    {
+        ScopedIndent cl(this);
+
+        line() << "target: [";
+        {
+            ScopedIndent tgt(this);
+            if (!EmitExpression(expr->target)) {
+                return false;
+            }
+        }
+        line() << "]";
+
+        if (!expr->args.IsEmpty()) {
+            line() << "args: [";
+            {
+                ScopedIndent args(this);
+                for (auto* arg : expr->args) {
+                    line() << "arg: [";
+                    {
+                        ScopedIndent arg_val(this);
+                        if (!EmitExpression(arg)) {
+                            return false;
+                        }
+                    }
+                    line() << "]";
+                }
+            }
+            line() << "]";
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitLiteral(const ast::LiteralExpression* lit) {
+    bool ret = false;
+    line() << "LiteralExpression [";
+    {
+        ScopedIndent le(this);
+        ret = Switch(
+            lit,
+            [&](const ast::BoolLiteralExpression* l) {  //
+                line() << (l->value ? "true" : "false");
+                return true;
+            },
+            [&](const ast::FloatLiteralExpression* l) {  //
+                // f16 literals are also emitted as float value with suffix "h".
+                // Note that all normal and subnormal f16 values are normal f32 values, and since
+                // NaN and Inf are not allowed to be spelled in literal, it should be fine to emit
+                // f16 literals in this way.
+                if (l->suffix == ast::FloatLiteralExpression::Suffix::kNone) {
+                    line() << DoubleToBitPreservingString(l->value);
+                } else {
+                    line() << FloatToBitPreservingString(static_cast<float>(l->value)) << l->suffix;
+                }
+                return true;
+            },
+            [&](const ast::IntLiteralExpression* l) {  //
+                line() << l->value << l->suffix;
+                return true;
+            },
+            [&](Default) {  //
+                diagnostics_.add_error(diag::System::Writer, "unknown literal type");
+                return false;
+            });
+    }
+    line() << "]";
+    return ret;
+}
+
+bool GeneratorImpl::EmitIdentifier(const ast::IdentifierExpression* expr) {
+    bool ret = false;
+    line() << "IdentifierExpression [";
+    {
+        ScopedIndent ie(this);
+        ret = EmitIdentifier(expr->identifier);
+    }
+    line() << "]";
+    return ret;
+}
+
+bool GeneratorImpl::EmitIdentifier(const ast::Identifier* ident) {
+    line() << "Identifier [";
+    {
+        ScopedIndent id(this);
+        if (auto* tmpl_ident = ident->As<ast::TemplatedIdentifier>()) {
+            line() << "Templated [";
+            {
+                ScopedIndent tmpl(this);
+                if (!tmpl_ident->attributes.IsEmpty()) {
+                    line() << "attrs: [";
+                    {
+                        ScopedIndent attrs(this);
+                        EmitAttributes(tmpl_ident->attributes);
+                    }
+                    line() << "]";
+                }
+                line() << "name: " << program_->Symbols().NameFor(ident->symbol);
+                if (!tmpl_ident->arguments.IsEmpty()) {
+                    line() << "args: [";
+                    {
+                        ScopedIndent args(this);
+                        for (auto* expr : tmpl_ident->arguments) {
+                            if (!EmitExpression(expr)) {
+                                return false;
+                            }
+                        }
+                    }
+                    line() << "]";
+                }
+            }
+            line() << "]";
+        } else {
+            line() << program_->Symbols().NameFor(ident->symbol);
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitFunction(const ast::Function* func) {
+    line() << "Function [";
+    {
+        ScopedIndent funct(this);
+
+        if (func->attributes.Length()) {
+            line() << "attrs: [";
+            {
+                ScopedIndent attrs(this);
+                if (!EmitAttributes(func->attributes)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+        line() << "name: " << program_->Symbols().NameFor(func->name->symbol);
+
+        if (!func->params.IsEmpty()) {
+            line() << "params: [";
+            {
+                ScopedIndent args(this);
+                for (auto* v : func->params) {
+                    line() << "param: [";
+                    {
+                        ScopedIndent param(this);
+                        line() << "name: " << program_->Symbols().NameFor(v->name->symbol);
+                        if (!v->attributes.IsEmpty()) {
+                            line() << "attrs: [";
+                            {
+                                ScopedIndent attrs(this);
+                                if (!EmitAttributes(v->attributes)) {
+                                    return false;
+                                }
+                            }
+                            line() << "]";
+                        }
+                        line() << "type: [";
+                        {
+                            ScopedIndent ty(this);
+                            if (!EmitExpression(v->type)) {
+                                return false;
+                            }
+                        }
+                        line() << "]";
+                    }
+                    line() << "]";
+                }
+            }
+            line() << "]";
+        }
+
+        line() << "return: [";
+        {
+            ScopedIndent ret(this);
+
+            if (func->return_type || !func->return_type_attributes.IsEmpty()) {
+                if (!func->return_type_attributes.IsEmpty()) {
+                    line() << "attrs: [";
+                    {
+                        ScopedIndent attrs(this);
+                        if (!EmitAttributes(func->return_type_attributes)) {
+                            return false;
+                        }
+                    }
+                    line() << "]";
+                }
+
+                line() << "type: [";
+                {
+                    ScopedIndent ty(this);
+                    if (!EmitExpression(func->return_type)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+            } else {
+                line() << "void";
+            }
+        }
+        line() << "]";
+        line() << "body: [";
+        {
+            ScopedIndent bdy(this);
+            if (func->body) {
+                if (!EmitBlockHeader(func->body)) {
+                    return false;
+                }
+                if (!EmitStatementsWithIndent(func->body->statements)) {
+                    return false;
+                }
+            }
+        }
+        line() << "]";
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitImageFormat(const builtin::TexelFormat fmt) {
+    line() << "builtin::TexelFormat [" << fmt << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitStructType(const ast::Struct* str) {
+    line() << "Struct [";
+    {
+        ScopedIndent strct(this);
+
+        if (str->attributes.Length()) {
+            line() << "attrs: [";
+            {
+                ScopedIndent attrs(this);
+                if (!EmitAttributes(str->attributes)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+        line() << "name: " << program_->Symbols().NameFor(str->name->symbol);
+        line() << "members: [";
+        {
+            ScopedIndent membs(this);
+
+            for (auto* mem : str->members) {
+                line() << "StructMember[";
+                {
+                    ScopedIndent m(this);
+                    if (!mem->attributes.IsEmpty()) {
+                        line() << "attrs: [";
+                        {
+                            ScopedIndent attrs(this);
+                            if (!EmitAttributes(mem->attributes)) {
+                                return false;
+                            }
+                        }
+                        line() << "]";
+                    }
+
+                    line() << "name: " << program_->Symbols().NameFor(mem->name->symbol);
+                    line() << "type: [";
+                    {
+                        ScopedIndent ty(this);
+                        if (!EmitExpression(mem->type)) {
+                            return false;
+                        }
+                    }
+                    line() << "]";
+                }
+            }
+            line() << "]";
+        }
+        line() << "]";
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitVariable(const ast::Variable* v) {
+    line() << "Variable [";
+    {
+        ScopedIndent variable(this);
+        if (!v->attributes.IsEmpty()) {
+            line() << "attrs: [";
+            {
+                ScopedIndent attr(this);
+                if (!EmitAttributes(v->attributes)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+
+        bool ok = Switch(
+            v,  //
+            [&](const ast::Var* var) {
+                if (var->declared_address_space || var->declared_access) {
+                    line() << "Var [";
+                    {
+                        ScopedIndent vr(this);
+                        line() << "address_space: [";
+                        {
+                            ScopedIndent addr(this);
+                            if (!EmitExpression(var->declared_address_space)) {
+                                return false;
+                            }
+                        }
+                        line() << "]";
+                        if (var->declared_access) {
+                            line() << "access: [";
+                            {
+                                ScopedIndent acs(this);
+                                if (!EmitExpression(var->declared_access)) {
+                                    return false;
+                                }
+                            }
+                            line() << "]";
+                        }
+                    }
+                    line() << "]";
+                } else {
+                    line() << "Var []";
+                }
+                return true;
+            },
+            [&](const ast::Let*) {
+                line() << "Let []";
+                return true;
+            },
+            [&](const ast::Override*) {
+                line() << "Override []";
+                return true;
+            },
+            [&](const ast::Const*) {
+                line() << "Const []";
+                return true;
+            },
+            [&](Default) {
+                TINT_ICE(Writer, diagnostics_) << "unhandled variable type " << v->TypeInfo().name;
+                return false;
+            });
+        if (!ok) {
+            return false;
+        }
+
+        line() << "name: " << program_->Symbols().NameFor(v->name->symbol);
+
+        if (auto ty = v->type) {
+            line() << "type: [";
+            {
+                ScopedIndent vty(this);
+                if (!EmitExpression(ty)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+
+        if (v->initializer != nullptr) {
+            line() << "initializer: [";
+            {
+                ScopedIndent init(this);
+                if (!EmitExpression(v->initializer)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitAttributes(utils::VectorRef<const ast::Attribute*> attrs) {
+    for (auto* attr : attrs) {
+        bool ok = Switch(
+            attr,
+            [&](const ast::WorkgroupAttribute* workgroup) {
+                auto values = workgroup->Values();
+                line() << "WorkgroupAttribute [";
+                {
+                    ScopedIndent wg(this);
+                    for (size_t i = 0; i < 3; i++) {
+                        if (values[i]) {
+                            if (!EmitExpression(values[i])) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::StageAttribute* stage) {
+                line() << "StageAttribute [" << stage->stage << "]";
+                return true;
+            },
+            [&](const ast::BindingAttribute* binding) {
+                line() << "BindingAttribute [";
+                {
+                    ScopedIndent ba(this);
+                    if (!EmitExpression(binding->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::GroupAttribute* group) {
+                line() << "GroupAttribute [";
+                {
+                    ScopedIndent ga(this);
+                    if (!EmitExpression(group->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::LocationAttribute* location) {
+                line() << "LocationAttribute [";
+                {
+                    ScopedIndent la(this);
+                    if (!EmitExpression(location->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::BuiltinAttribute* builtin) {
+                line() << "BuiltinAttribute [";
+                {
+                    ScopedIndent ba(this);
+                    if (!EmitExpression(builtin->builtin)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::DiagnosticAttribute* diagnostic) {
+                return EmitDiagnosticControl(diagnostic->control);
+            },
+            [&](const ast::InterpolateAttribute* interpolate) {
+                line() << "InterpolateAttribute [";
+                {
+                    ScopedIndent ia(this);
+                    line() << "type: [";
+                    {
+                        ScopedIndent ty(this);
+                        if (!EmitExpression(interpolate->type)) {
+                            return false;
+                        }
+                    }
+                    line() << "]";
+                    if (interpolate->sampling) {
+                        line() << "sampling: [";
+                        {
+                            ScopedIndent sa(this);
+                            if (!EmitExpression(interpolate->sampling)) {
+                                return false;
+                            }
+                        }
+                        line() << "]";
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::InvariantAttribute*) {
+                line() << "InvariantAttribute []";
+                return true;
+            },
+            [&](const ast::IdAttribute* override_deco) {
+                line() << "IdAttribute [";
+                {
+                    ScopedIndent id(this);
+                    if (!EmitExpression(override_deco->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::MustUseAttribute*) {
+                line() << "MustUseAttribute []";
+                return true;
+            },
+            [&](const ast::StructMemberOffsetAttribute* offset) {
+                line() << "StructMemberOffsetAttribute [";
+                {
+                    ScopedIndent smoa(this);
+                    if (!EmitExpression(offset->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::StructMemberSizeAttribute* size) {
+                line() << "StructMemberSizeAttribute [";
+                {
+                    ScopedIndent smsa(this);
+                    if (!EmitExpression(size->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::StructMemberAlignAttribute* align) {
+                line() << "StructMemberAlignAttribute [";
+                {
+                    ScopedIndent smaa(this);
+                    if (!EmitExpression(align->expr)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                return true;
+            },
+            [&](const ast::StrideAttribute* stride) {
+                line() << "StrideAttribute [" << stride->stride << "]";
+                return true;
+            },
+            [&](const ast::InternalAttribute* internal) {
+                line() << "InternalAttribute [" << internal->InternalName() << "]";
+                return true;
+            },
+            [&](Default) {
+                TINT_ICE(Writer, diagnostics_)
+                    << "Unsupported attribute '" << attr->TypeInfo().name << "'";
+                return false;
+            });
+
+        if (!ok) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool GeneratorImpl::EmitBinary(const ast::BinaryExpression* expr) {
+    line() << "BinaryExpression [";
+    {
+        ScopedIndent be(this);
+        line() << "lhs: [";
+        {
+            ScopedIndent lhs(this);
+
+            if (!EmitExpression(expr->lhs)) {
+                return false;
+            }
+        }
+        line() << "]";
+        line() << "op: [";
+        {
+            ScopedIndent op(this);
+            if (!EmitBinaryOp(expr->op)) {
+                return false;
+            }
+        }
+        line() << "]";
+        line() << "rhs: [";
+        {
+            ScopedIndent rhs(this);
+            if (!EmitExpression(expr->rhs)) {
+                return false;
+            }
+        }
+        line() << "]";
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitBinaryOp(const ast::BinaryOp op) {
+    switch (op) {
+        case ast::BinaryOp::kAnd:
+            line() << "&";
+            break;
+        case ast::BinaryOp::kOr:
+            line() << "|";
+            break;
+        case ast::BinaryOp::kXor:
+            line() << "^";
+            break;
+        case ast::BinaryOp::kLogicalAnd:
+            line() << "&&";
+            break;
+        case ast::BinaryOp::kLogicalOr:
+            line() << "||";
+            break;
+        case ast::BinaryOp::kEqual:
+            line() << "==";
+            break;
+        case ast::BinaryOp::kNotEqual:
+            line() << "!=";
+            break;
+        case ast::BinaryOp::kLessThan:
+            line() << "<";
+            break;
+        case ast::BinaryOp::kGreaterThan:
+            line() << ">";
+            break;
+        case ast::BinaryOp::kLessThanEqual:
+            line() << "<=";
+            break;
+        case ast::BinaryOp::kGreaterThanEqual:
+            line() << ">=";
+            break;
+        case ast::BinaryOp::kShiftLeft:
+            line() << "<<";
+            break;
+        case ast::BinaryOp::kShiftRight:
+            line() << ">>";
+            break;
+        case ast::BinaryOp::kAdd:
+            line() << "+";
+            break;
+        case ast::BinaryOp::kSubtract:
+            line() << "-";
+            break;
+        case ast::BinaryOp::kMultiply:
+            line() << "*";
+            break;
+        case ast::BinaryOp::kDivide:
+            line() << "/";
+            break;
+        case ast::BinaryOp::kModulo:
+            line() << "%";
+            break;
+        case ast::BinaryOp::kNone:
+            diagnostics_.add_error(diag::System::Writer, "missing binary operation type");
+            return false;
+    }
+    return true;
+}
+
+bool GeneratorImpl::EmitUnaryOp(const ast::UnaryOpExpression* expr) {
+    line() << "UnaryOpExpression [";
+    {
+        ScopedIndent uoe(this);
+        line() << "op: [";
+        {
+            ScopedIndent op(this);
+            switch (expr->op) {
+                case ast::UnaryOp::kAddressOf:
+                    line() << "&";
+                    break;
+                case ast::UnaryOp::kComplement:
+                    line() << "~";
+                    break;
+                case ast::UnaryOp::kIndirection:
+                    line() << "*";
+                    break;
+                case ast::UnaryOp::kNot:
+                    line() << "!";
+                    break;
+                case ast::UnaryOp::kNegation:
+                    line() << "-";
+                    break;
+            }
+        }
+        line() << "]";
+        line() << "expr: [";
+        {
+            ScopedIndent ex(this);
+            if (!EmitExpression(expr->expr)) {
+                return false;
+            }
+        }
+        line() << "]";
+    }
+    line() << "]";
+
+    return true;
+}
+
+bool GeneratorImpl::EmitBlock(const ast::BlockStatement* stmt) {
+    {
+        if (!EmitBlockHeader(stmt)) {
+            return false;
+        }
+    }
+    if (!EmitStatementsWithIndent(stmt->statements)) {
+        return false;
+    }
+
+    return true;
+}
+
+bool GeneratorImpl::EmitBlockHeader(const ast::BlockStatement* stmt) {
+    if (!stmt->attributes.IsEmpty()) {
+        line() << "attrs: [";
+        {
+            ScopedIndent attrs(this);
+            if (!EmitAttributes(stmt->attributes)) {
+                return false;
+            }
+        }
+        line() << "]";
+    }
+    return true;
+}
+
+bool GeneratorImpl::EmitStatement(const ast::Statement* stmt) {
+    return Switch(
+        stmt,  //
+        [&](const ast::AssignmentStatement* a) { return EmitAssign(a); },
+        [&](const ast::BlockStatement* b) { return EmitBlock(b); },
+        [&](const ast::BreakStatement* b) { return EmitBreak(b); },
+        [&](const ast::BreakIfStatement* b) { return EmitBreakIf(b); },
+        [&](const ast::CallStatement* c) { return EmitCall(c->expr); },
+        [&](const ast::CompoundAssignmentStatement* c) { return EmitCompoundAssign(c); },
+        [&](const ast::ContinueStatement* c) { return EmitContinue(c); },
+        [&](const ast::DiscardStatement* d) { return EmitDiscard(d); },
+        [&](const ast::IfStatement* i) { return EmitIf(i); },
+        [&](const ast::IncrementDecrementStatement* l) { return EmitIncrementDecrement(l); },
+        [&](const ast::LoopStatement* l) { return EmitLoop(l); },
+        [&](const ast::ForLoopStatement* l) { return EmitForLoop(l); },
+        [&](const ast::WhileStatement* l) { return EmitWhile(l); },
+        [&](const ast::ReturnStatement* r) { return EmitReturn(r); },
+        [&](const ast::ConstAssert* c) { return EmitConstAssert(c); },
+        [&](const ast::SwitchStatement* s) { return EmitSwitch(s); },
+        [&](const ast::VariableDeclStatement* v) { return EmitVariable(v->variable); },
+        [&](Default) {
+            diagnostics_.add_error(diag::System::Writer,
+                                   "unknown statement type: " + std::string(stmt->TypeInfo().name));
+            return false;
+        });
+}
+
+bool GeneratorImpl::EmitStatements(utils::VectorRef<const ast::Statement*> stmts) {
+    for (auto* s : stmts) {
+        if (!EmitStatement(s)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool GeneratorImpl::EmitStatementsWithIndent(utils::VectorRef<const ast::Statement*> stmts) {
+    ScopedIndent si(this);
+    return EmitStatements(stmts);
+}
+
+bool GeneratorImpl::EmitAssign(const ast::AssignmentStatement* stmt) {
+    line() << "AssignmentStatement [";
+    {
+        ScopedIndent as(this);
+        line() << "lhs: [";
+        {
+            ScopedIndent lhs(this);
+            if (!EmitExpression(stmt->lhs)) {
+                return false;
+            }
+        }
+        line() << "]";
+        line() << "rhs: [";
+        {
+            ScopedIndent rhs(this);
+            if (!EmitExpression(stmt->rhs)) {
+                return false;
+            }
+            line() << "]";
+        }
+    }
+    line() << "]";
+
+    return true;
+}
+
+bool GeneratorImpl::EmitBreak(const ast::BreakStatement*) {
+    line() << "BreakStatement []";
+    return true;
+}
+
+bool GeneratorImpl::EmitBreakIf(const ast::BreakIfStatement* b) {
+    line() << "BreakIfStatement [";
+    {
+        ScopedIndent bis(this);
+        if (!EmitExpression(b->condition)) {
+            return false;
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitCase(const ast::CaseStatement* stmt) {
+    line() << "CaseStatement [";
+    {
+        ScopedIndent cs(this);
+        if (stmt->selectors.Length() == 1 && stmt->ContainsDefault()) {
+            line() << "selector: default";
+            if (!EmitBlockHeader(stmt->body)) {
+                return false;
+            }
+        } else {
+            line() << "selectors: [";
+            {
+                ScopedIndent sels(this);
+                for (auto* sel : stmt->selectors) {
+                    if (sel->IsDefault()) {
+                        line() << "default []";
+                    } else if (!EmitExpression(sel->expr)) {
+                        return false;
+                    }
+                }
+            }
+            line() << "]";
+            if (!EmitBlockHeader(stmt->body)) {
+                return false;
+            }
+        }
+        if (!EmitStatementsWithIndent(stmt->body->statements)) {
+            return false;
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitCompoundAssign(const ast::CompoundAssignmentStatement* stmt) {
+    line() << "CompoundAssignmentStatement [";
+    {
+        ScopedIndent cas(this);
+        line() << "lhs: [";
+        {
+            ScopedIndent lhs(this);
+            if (!EmitExpression(stmt->lhs)) {
+                return false;
+            }
+        }
+        line() << "]";
+
+        line() << "op: [";
+        {
+            ScopedIndent op(this);
+            if (!EmitBinaryOp(stmt->op)) {
+                return false;
+            }
+        }
+        line() << "]";
+        line() << "rhs: [";
+        {
+            ScopedIndent rhs(this);
+
+            if (!EmitExpression(stmt->rhs)) {
+                return false;
+            }
+        }
+        line() << "]";
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitContinue(const ast::ContinueStatement*) {
+    line() << "ContinueStatement []";
+    return true;
+}
+
+bool GeneratorImpl::EmitIf(const ast::IfStatement* stmt) {
+    {
+        line() << "IfStatement [";
+        {
+            ScopedIndent ifs(this);
+            line() << "condition: [";
+            {
+                ScopedIndent cond(this);
+                if (!EmitExpression(stmt->condition)) {
+                    return false;
+                }
+            }
+            line() << "]";
+            if (!EmitBlockHeader(stmt->body)) {
+                return false;
+            }
+        }
+        line() << "] ";
+    }
+    if (!EmitStatementsWithIndent(stmt->body->statements)) {
+        return false;
+    }
+
+    const ast::Statement* e = stmt->else_statement;
+    while (e) {
+        if (auto* elseif = e->As<ast::IfStatement>()) {
+            {
+                line() << "Else IfStatement [";
+                {
+                    ScopedIndent ifs(this);
+                    line() << "condition: [";
+                    if (!EmitExpression(elseif->condition)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+                if (!EmitBlockHeader(elseif->body)) {
+                    return false;
+                }
+            }
+            line() << "]";
+            if (!EmitStatementsWithIndent(elseif->body->statements)) {
+                return false;
+            }
+            e = elseif->else_statement;
+        } else {
+            auto* body = e->As<ast::BlockStatement>();
+            {
+                line() << "Else [";
+                {
+                    ScopedIndent els(this);
+                    if (!EmitBlockHeader(body)) {
+                        return false;
+                    }
+                }
+                line() << "]";
+            }
+            if (!EmitStatementsWithIndent(body->statements)) {
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+
+bool GeneratorImpl::EmitIncrementDecrement(const ast::IncrementDecrementStatement* stmt) {
+    line() << "IncrementDecrementStatement [";
+    {
+        ScopedIndent ids(this);
+        line() << "expr: [";
+        if (!EmitExpression(stmt->lhs)) {
+            return false;
+        }
+        line() << "]";
+        line() << "dir: " << (stmt->increment ? "++" : "--");
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitDiscard(const ast::DiscardStatement*) {
+    line() << "DiscardStatement []";
+    return true;
+}
+
+bool GeneratorImpl::EmitLoop(const ast::LoopStatement* stmt) {
+    line() << "LoopStatement [";
+    {
+        ScopedIndent ls(this);
+        if (!EmitStatements(stmt->body->statements)) {
+            return false;
+        }
+
+        if (stmt->continuing && !stmt->continuing->Empty()) {
+            line() << "Continuing [";
+            {
+                ScopedIndent cont(this);
+                if (!EmitStatementsWithIndent(stmt->continuing->statements)) {
+                    return false;
+                }
+            }
+            line() << "]";
+        }
+    }
+    line() << "]";
+
+    return true;
+}
+
+bool GeneratorImpl::EmitForLoop(const ast::ForLoopStatement* stmt) {
+    TextBuffer init_buf;
+    if (auto* init = stmt->initializer) {
+        TINT_SCOPED_ASSIGNMENT(current_buffer_, &init_buf);
+        if (!EmitStatement(init)) {
+            return false;
+        }
+    }
+
+    TextBuffer cont_buf;
+    if (auto* cont = stmt->continuing) {
+        TINT_SCOPED_ASSIGNMENT(current_buffer_, &cont_buf);
+        if (!EmitStatement(cont)) {
+            return false;
+        }
+    }
+
+    line() << "ForLoopStatement [";
+    {
+        ScopedIndent fs(this);
+
+        line() << "initializer: [";
+        {
+            ScopedIndent init(this);
+            switch (init_buf.lines.size()) {
+                case 0:  // No initializer
+                    break;
+                case 1:  // Single line initializer statement
+                    line() << TrimSuffix(init_buf.lines[0].content, ";");
+                    break;
+                default:  // Block initializer statement
+                    for (size_t i = 1; i < init_buf.lines.size(); i++) {
+                        // Indent all by the first line
+                        init_buf.lines[i].indent += current_buffer_->current_indent;
+                    }
+                    line() << TrimSuffix(init_buf.String(), "\n");
+                    break;
+            }
+        }
+        line() << "]";
+        line() << "condition: [";
+        {
+            ScopedIndent con(this);
+            if (auto* cond = stmt->condition) {
+                if (!EmitExpression(cond)) {
+                    return false;
+                }
+            }
+        }
+
+        line() << "]";
+        line() << "continuing: [";
+        {
+            ScopedIndent cont(this);
+            switch (cont_buf.lines.size()) {
+                case 0:  // No continuing
+                    break;
+                case 1:  // Single line continuing statement
+                    line() << TrimSuffix(cont_buf.lines[0].content, ";");
+                    break;
+                default:  // Block continuing statement
+                    for (size_t i = 1; i < cont_buf.lines.size(); i++) {
+                        // Indent all by the first line
+                        cont_buf.lines[i].indent += current_buffer_->current_indent;
+                    }
+                    line() << TrimSuffix(cont_buf.String(), "\n");
+                    break;
+            }
+        }
+        if (!EmitBlockHeader(stmt->body)) {
+            return false;
+        }
+
+        if (!EmitStatementsWithIndent(stmt->body->statements)) {
+            return false;
+        }
+    }
+    line() << "]";
+
+    return true;
+}
+
+bool GeneratorImpl::EmitWhile(const ast::WhileStatement* stmt) {
+    line() << "WhileStatement [";
+    {
+        ScopedIndent ws(this);
+        {
+            auto* cond = stmt->condition;
+            if (!EmitExpression(cond)) {
+                return false;
+            }
+        }
+        if (!EmitBlockHeader(stmt->body)) {
+            return false;
+        }
+        if (!EmitStatementsWithIndent(stmt->body->statements)) {
+            return false;
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitReturn(const ast::ReturnStatement* stmt) {
+    line() << "ReturnStatement [";
+    {
+        ScopedIndent ret(this);
+        if (stmt->value) {
+            if (!EmitExpression(stmt->value)) {
+                return false;
+            }
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitConstAssert(const ast::ConstAssert* stmt) {
+    line() << "ConstAssert [";
+    {
+        ScopedIndent ca(this);
+        if (!EmitExpression(stmt->condition)) {
+            return false;
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) {
+    line() << "SwitchStatement [";
+    {
+        ScopedIndent ss(this);
+        line() << "condition: [";
+        {
+            ScopedIndent cond(this);
+            if (!EmitExpression(stmt->condition)) {
+                return false;
+            }
+        }
+        line() << "]";
+
+        {
+            ScopedIndent si(this);
+            for (auto* s : stmt->body) {
+                if (!EmitCase(s)) {
+                    return false;
+                }
+            }
+        }
+    }
+    line() << "]";
+    return true;
+}
+
+}  // namespace tint::writer::syntax_tree
diff --git a/src/tint/writer/syntax_tree/generator_impl.h b/src/tint/writer/syntax_tree/generator_impl.h
new file mode 100644
index 0000000..8b9a187
--- /dev/null
+++ b/src/tint/writer/syntax_tree/generator_impl.h
@@ -0,0 +1,215 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_
+#define SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_
+
+#include <string>
+
+#include "src/tint/ast/assignment_statement.h"
+#include "src/tint/ast/binary_expression.h"
+#include "src/tint/ast/bitcast_expression.h"
+#include "src/tint/ast/break_if_statement.h"
+#include "src/tint/ast/break_statement.h"
+#include "src/tint/ast/compound_assignment_statement.h"
+#include "src/tint/ast/continue_statement.h"
+#include "src/tint/ast/discard_statement.h"
+#include "src/tint/ast/for_loop_statement.h"
+#include "src/tint/ast/if_statement.h"
+#include "src/tint/ast/index_accessor_expression.h"
+#include "src/tint/ast/loop_statement.h"
+#include "src/tint/ast/member_accessor_expression.h"
+#include "src/tint/ast/return_statement.h"
+#include "src/tint/ast/switch_statement.h"
+#include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/program.h"
+#include "src/tint/sem/struct.h"
+#include "src/tint/utils/string_stream.h"
+#include "src/tint/writer/text_generator.h"
+
+namespace tint::writer::syntax_tree {
+
+/// Implementation class for AST generator
+class GeneratorImpl : public TextGenerator {
+  public:
+    /// Constructor
+    /// @param program the program
+    explicit GeneratorImpl(const Program* program);
+    ~GeneratorImpl();
+
+    /// Generates the result data
+    /// @returns true on successful generation; false otherwise
+    bool Generate();
+
+    /// Handles generating a diagnostic control
+    /// @param diagnostic the diagnostic control node
+    /// @returns true if the diagnostic control was emitted
+    bool EmitDiagnosticControl(const ast::DiagnosticControl& diagnostic);
+    /// Handles generating an enable directive
+    /// @param enable the enable node
+    /// @returns true if the enable directive was emitted
+    bool EmitEnable(const ast::Enable* enable);
+    /// Handles generating a declared type
+    /// @param ty the declared type to generate
+    /// @returns true if the declared type was emitted
+    bool EmitTypeDecl(const ast::TypeDecl* ty);
+    /// Handles an index accessor expression
+    /// @param expr the expression to emit
+    /// @returns true if the index accessor was emitted
+    bool EmitIndexAccessor(const ast::IndexAccessorExpression* expr);
+    /// Handles an assignment statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitAssign(const ast::AssignmentStatement* stmt);
+    /// Handles generating a binary expression
+    /// @param expr the binary expression
+    /// @returns true if the expression was emitted, false otherwise
+    bool EmitBinary(const ast::BinaryExpression* expr);
+    /// Handles generating a binary operator
+    /// @param op the binary operator
+    /// @returns true if the operator was emitted, false otherwise
+    bool EmitBinaryOp(const ast::BinaryOp op);
+    /// Handles generating a bitcast expression
+    /// @param expr the bitcast expression
+    /// @returns true if the bitcast was emitted
+    bool EmitBitcast(const ast::BitcastExpression* expr);
+    /// Handles a block statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitBlock(const ast::BlockStatement* stmt);
+    /// Handles emitting the start of a block statement (including attributes)
+    /// @param stmt the block statement to emit the header for
+    /// @returns true if the statement was emitted successfully
+    bool EmitBlockHeader(const ast::BlockStatement* stmt);
+    /// Handles a break statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitBreak(const ast::BreakStatement* stmt);
+    /// Handles a break-if statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitBreakIf(const ast::BreakIfStatement* stmt);
+    /// Handles generating a call expression
+    /// @param expr the call expression
+    /// @returns true if the call expression is emitted
+    bool EmitCall(const ast::CallExpression* expr);
+    /// Handles a case statement
+    /// @param stmt the statement
+    /// @returns true if the statment was emitted successfully
+    bool EmitCase(const ast::CaseStatement* stmt);
+    /// Handles a compound assignment statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitCompoundAssign(const ast::CompoundAssignmentStatement* stmt);
+    /// Handles generating a literal expression
+    /// @param expr the literal expression expression
+    /// @returns true if the literal expression is emitted
+    bool EmitLiteral(const ast::LiteralExpression* expr);
+    /// Handles a continue statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted successfully
+    bool EmitContinue(const ast::ContinueStatement* stmt);
+    /// Handles generate an Expression
+    /// @param expr the expression
+    /// @returns true if the expression was emitted
+    bool EmitExpression(const ast::Expression* expr);
+    /// Handles generating a function
+    /// @param func the function to generate
+    /// @returns true if the function was emitted
+    bool EmitFunction(const ast::Function* func);
+    /// Handles generating an identifier expression
+    /// @param expr the identifier expression
+    /// @returns true if the identifier was emitted
+    bool EmitIdentifier(const ast::IdentifierExpression* expr);
+    /// Handles generating an identifier
+    /// @param ident the identifier
+    /// @returns true if the identifier was emitted
+    bool EmitIdentifier(const ast::Identifier* ident);
+    /// Handles an if statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was successfully emitted
+    bool EmitIf(const ast::IfStatement* stmt);
+    /// Handles an increment/decrement statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was successfully emitted
+    bool EmitIncrementDecrement(const ast::IncrementDecrementStatement* stmt);
+    /// Handles generating a discard statement
+    /// @param stmt the discard statement
+    /// @returns true if the statement was successfully emitted
+    bool EmitDiscard(const ast::DiscardStatement* stmt);
+    /// Handles a loop statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emtited
+    bool EmitLoop(const ast::LoopStatement* stmt);
+    /// Handles a for-loop statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emtited
+    bool EmitForLoop(const ast::ForLoopStatement* stmt);
+    /// Handles a while statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emtited
+    bool EmitWhile(const ast::WhileStatement* stmt);
+    /// Handles a member accessor expression
+    /// @param expr the member accessor expression
+    /// @returns true if the member accessor was emitted
+    bool EmitMemberAccessor(const ast::MemberAccessorExpression* expr);
+    /// Handles return statements
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was successfully emitted
+    bool EmitReturn(const ast::ReturnStatement* stmt);
+    /// Handles const assertion statements
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was successfully emitted
+    bool EmitConstAssert(const ast::ConstAssert* stmt);
+    /// Handles statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted
+    bool EmitStatement(const ast::Statement* stmt);
+    /// Handles a statement list
+    /// @param stmts the statements to emit
+    /// @returns true if the statements were emitted
+    bool EmitStatements(utils::VectorRef<const ast::Statement*> stmts);
+    /// Handles a statement list with an increased indentation
+    /// @param stmts the statements to emit
+    /// @returns true if the statements were emitted
+    bool EmitStatementsWithIndent(utils::VectorRef<const ast::Statement*> stmts);
+    /// Handles generating a switch statement
+    /// @param stmt the statement to emit
+    /// @returns true if the statement was emitted
+    bool EmitSwitch(const ast::SwitchStatement* stmt);
+    /// Handles generating a struct declaration
+    /// @param str the struct
+    /// @returns true if the struct is emitted
+    bool EmitStructType(const ast::Struct* str);
+    /// Handles emitting an image format
+    /// @param fmt the format to generate
+    /// @returns true if the format is emitted
+    bool EmitImageFormat(const builtin::TexelFormat fmt);
+    /// Handles a unary op expression
+    /// @param expr the expression to emit
+    /// @returns true if the expression was emitted
+    bool EmitUnaryOp(const ast::UnaryOpExpression* expr);
+    /// Handles generating a variable
+    /// @param var the variable to generate
+    /// @returns true if the variable was emitted
+    bool EmitVariable(const ast::Variable* var);
+    /// Handles generating a attribute list
+    /// @param attrs the attribute list
+    /// @returns true if the attributes were emitted
+    bool EmitAttributes(utils::VectorRef<const ast::Attribute*> attrs);
+};
+
+}  // namespace tint::writer::syntax_tree
+
+#endif  // SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_
diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc
index 69aaabd..2b5f474 100644
--- a/src/tint/writer/wgsl/generator_impl.cc
+++ b/src/tint/writer/wgsl/generator_impl.cc
@@ -34,6 +34,8 @@
 #include "src/tint/ast/workgroup_attribute.h"
 #include "src/tint/sem/struct.h"
 #include "src/tint/sem/switch_statement.h"
+#include "src/tint/switch.h"
+#include "src/tint/utils/defer.h"
 #include "src/tint/utils/math.h"
 #include "src/tint/utils/scoped_assignment.h"
 #include "src/tint/writer/float_to_string.h"
@@ -98,7 +100,14 @@
 
 bool GeneratorImpl::EmitEnable(const ast::Enable* enable) {
     auto out = line();
-    out << "enable " << enable->extension << ";";
+    out << "enable ";
+    for (auto* ext : enable->extensions) {
+        if (ext != enable->extensions.Front()) {
+            out << ", ";
+        }
+        out << ext->name;
+    }
+    out << ";";
     return true;
 }
 
@@ -940,6 +949,14 @@
 bool GeneratorImpl::EmitIf(const ast::IfStatement* stmt) {
     {
         auto out = line();
+
+        if (!stmt->attributes.IsEmpty()) {
+            if (!EmitAttributes(out, stmt->attributes)) {
+                return false;
+            }
+            out << " ";
+        }
+
         out << "if (";
         if (!EmitExpression(out, stmt->condition)) {
             return false;
@@ -1049,6 +1066,14 @@
 
     {
         auto out = line();
+
+        if (!stmt->attributes.IsEmpty()) {
+            if (!EmitAttributes(out, stmt->attributes)) {
+                return false;
+            }
+            out << " ";
+        }
+
         out << "for";
         {
             ScopedParen sp(out);
@@ -1110,6 +1135,14 @@
 bool GeneratorImpl::EmitWhile(const ast::WhileStatement* stmt) {
     {
         auto out = line();
+
+        if (!stmt->attributes.IsEmpty()) {
+            if (!EmitAttributes(out, stmt->attributes)) {
+                return false;
+            }
+            out << " ";
+        }
+
         out << "while";
         {
             ScopedParen sp(out);
@@ -1160,6 +1193,14 @@
 bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) {
     {
         auto out = line();
+
+        if (!stmt->attributes.IsEmpty()) {
+            if (!EmitAttributes(out, stmt->attributes)) {
+                return false;
+            }
+            out << " ";
+        }
+
         out << "switch(";
         if (!EmitExpression(out, stmt->condition)) {
             return false;
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
index bf1542c..3ee0d99 100644
--- a/third_party/CMakeLists.txt
+++ b/third_party/CMakeLists.txt
@@ -51,3 +51,18 @@
     add_subdirectory("${TINT_THIRD_PARTY_DIR}/vulkan-deps/glslang/src" "${CMAKE_BINARY_DIR}/third_party/glslang" EXCLUDE_FROM_ALL)
   endif()
 endif()
+
+if (NOT TARGET libabsl)
+    if (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR
+        ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang"))
+        add_compile_options(
+            -Wno-array-parameter
+            -Wno-deprecated-builtins
+            -Wno-unknown-warning-option
+        )
+    endif()
+
+    # Recommended setting for compability with future abseil releases.
+    set(ABSL_PROPAGATE_CXX_STD ON)
+    add_subdirectory("${TINT_THIRD_PARTY_DIR}/abseil-cpp" "${CMAKE_CURRENT_BINARY_DIR}/abseil")
+endif()
diff --git a/third_party/gn/abseil-cpp/BUILD.gn b/third_party/gn/abseil-cpp/BUILD.gn
new file mode 100644
index 0000000..60c9406
--- /dev/null
+++ b/third_party/gn/abseil-cpp/BUILD.gn
@@ -0,0 +1,168 @@
+# Copyright 2021 The Dawn Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("../../../scripts/dawn_overrides_with_defaults.gni")
+
+config("absl_config") {
+  if (is_clang) {
+    cflags = [
+      # Allow the use of enable_if()
+      "-Wno-gcc-compat",
+    ]
+  }
+
+  include_dirs = [ "${dawn_abseil_dir}" ]
+}
+
+template("absl_source_set") {
+  source_set(target_name) {
+    forward_variables_from(invoker, "*")
+
+    if (!defined(public_configs)) {
+      public_configs = []
+    }
+    public_configs += [ ":absl_config" ]
+  }
+}
+
+#
+# absl/base
+#
+
+absl_source_set("log_severity") {
+  sources = [ "${dawn_abseil_dir}/absl/base/log_severity.cc" ]
+  public = [ "${dawn_abseil_dir}/absl/base/log_severity.h" ]
+}
+
+absl_source_set("raw_logging_internal") {
+  sources = [ "${dawn_abseil_dir}/absl/base/internal/raw_logging.cc" ]
+  public = [ "${dawn_abseil_dir}/absl/base/internal/raw_logging.h" ]
+  public_deps = [ ":log_severity" ]
+  visibility = [ ":*" ]
+}
+
+absl_source_set("throw_delegate") {
+  sources = [ "${dawn_abseil_dir}/absl/base/internal/throw_delegate.cc" ]
+  public = [ "${dawn_abseil_dir}/absl/base/internal/throw_delegate.h" ]
+  public_deps = [ ":raw_logging_internal" ]
+  visibility = [ ":*" ]
+}
+
+#
+# absl/numeric
+#
+
+absl_source_set("int128") {
+  sources = [
+    "${dawn_abseil_dir}/absl/numeric/int128.cc",
+    "${dawn_abseil_dir}/absl/numeric/int128_have_intrinsic.inc",
+    "${dawn_abseil_dir}/absl/numeric/int128_no_intrinsic.inc",
+  ]
+  public = [ "${dawn_abseil_dir}/absl/numeric/int128.h" ]
+}
+
+#
+# absl/strings
+#
+
+absl_source_set("strings") {
+  sources = [
+    "${dawn_abseil_dir}/absl/strings/ascii.cc",
+    "${dawn_abseil_dir}/absl/strings/charconv.cc",
+    "${dawn_abseil_dir}/absl/strings/escaping.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/charconv_bigint.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/charconv_bigint.h",
+    "${dawn_abseil_dir}/absl/strings/internal/charconv_parse.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/charconv_parse.h",
+    "${dawn_abseil_dir}/absl/strings/internal/memutil.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/memutil.h",
+    "${dawn_abseil_dir}/absl/strings/internal/stl_type_traits.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_join_internal.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_split_internal.h",
+    "${dawn_abseil_dir}/absl/strings/match.cc",
+    "${dawn_abseil_dir}/absl/strings/numbers.cc",
+    "${dawn_abseil_dir}/absl/strings/str_cat.cc",
+    "${dawn_abseil_dir}/absl/strings/str_replace.cc",
+    "${dawn_abseil_dir}/absl/strings/str_split.cc",
+    "${dawn_abseil_dir}/absl/strings/string_view.cc",
+    "${dawn_abseil_dir}/absl/strings/substitute.cc",
+  ]
+  public = [
+    "${dawn_abseil_dir}/absl/strings/ascii.h",
+    "${dawn_abseil_dir}/absl/strings/charconv.h",
+    "${dawn_abseil_dir}/absl/strings/escaping.h",
+    "${dawn_abseil_dir}/absl/strings/internal/string_constant.h",
+    "${dawn_abseil_dir}/absl/strings/match.h",
+    "${dawn_abseil_dir}/absl/strings/numbers.h",
+    "${dawn_abseil_dir}/absl/strings/str_cat.h",
+    "${dawn_abseil_dir}/absl/strings/str_join.h",
+    "${dawn_abseil_dir}/absl/strings/str_replace.h",
+    "${dawn_abseil_dir}/absl/strings/str_split.h",
+    "${dawn_abseil_dir}/absl/strings/string_view.h",
+    "${dawn_abseil_dir}/absl/strings/strip.h",
+    "${dawn_abseil_dir}/absl/strings/substitute.h",
+  ]
+  deps = [
+    ":int128",
+    ":raw_logging_internal",
+    ":strings_internal",
+    ":throw_delegate",
+  ]
+}
+
+absl_source_set("strings_internal") {
+  sources = [
+    "${dawn_abseil_dir}/absl/strings/internal/escaping.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/ostringstream.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/utf8.cc",
+  ]
+  public = [
+    "${dawn_abseil_dir}/absl/strings/internal/char_map.h",
+    "${dawn_abseil_dir}/absl/strings/internal/escaping.h",
+    "${dawn_abseil_dir}/absl/strings/internal/ostringstream.h",
+    "${dawn_abseil_dir}/absl/strings/internal/resize_uninitialized.h",
+    "${dawn_abseil_dir}/absl/strings/internal/utf8.h",
+  ]
+  deps = [ ":raw_logging_internal" ]
+}
+
+absl_source_set("str_format") {
+  public = [ "${dawn_abseil_dir}/absl/strings/str_format.h" ]
+  deps = [ ":str_format_internal" ]
+}
+
+absl_source_set("str_format_internal") {
+  sources = [
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/arg.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/bind.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/extension.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/float_conversion.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/output.cc",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/parser.cc",
+  ]
+  public = [
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/arg.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/bind.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/checker.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/extension.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/float_conversion.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/output.h",
+    "${dawn_abseil_dir}/absl/strings/internal/str_format/parser.h",
+  ]
+  visibility = [ ":*" ]
+  deps = [
+    ":int128",
+    ":strings",
+  ]
+}
diff --git a/tint_overrides_with_defaults.gni b/tint_overrides_with_defaults.gni
index 9e39248..c54915d 100644
--- a/tint_overrides_with_defaults.gni
+++ b/tint_overrides_with_defaults.gni
@@ -72,6 +72,11 @@
     tint_build_glsl_writer = true
   }
 
+  # Build the Syntax Tree writer
+  if (!defined(tint_build_syntax_tree_writer)) {
+    tint_build_syntax_tree_writer = false
+  }
+
   # Build unittests
   if (!defined(tint_build_unittests)) {
     tint_build_unittests = true