diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 663ba05..492e355 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -131,7 +131,7 @@
     sources += [ "utils/io/tmpfile_other.cc" ]
   }
 
-  deps = [ ":libtint_base_src" ]
+  deps = [ ":libtint_utils_src" ]
 }
 
 ###############################################################################
@@ -147,8 +147,8 @@
   ]
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_program_src",
+    ":libtint_utils_src",
     ":tint_utils_io",
   ]
 }
@@ -193,7 +193,26 @@
   }
 }
 
-libtint_source_set("libtint_base_src") {
+libtint_source_set("libtint_symbols_src") {
+  sources = [
+    "number.cc",
+    "number.h",
+    "program_id.cc",
+    "program_id.h",
+    "reflection.h",
+    "scope_stack.h",
+    "symbol.cc",
+    "symbol.h",
+    "symbol_table.cc",
+    "symbol_table.h",
+  ]
+  deps = [
+    ":libtint_builtins_src",
+    ":libtint_utils_src",
+  ]
+}
+
+libtint_source_set("libtint_utils_src") {
   sources = [
     "debug.cc",
     "debug.h",
@@ -203,19 +222,9 @@
     "diagnostic/formatter.h",
     "diagnostic/printer.cc",
     "diagnostic/printer.h",
-    "number.cc",
-    "number.h",
-    "program_id.cc",
-    "program_id.h",
-    "reflection.h",
-    "scope_stack.h",
     "source.cc",
     "source.h",
     "switch.h",
-    "symbol.cc",
-    "symbol.h",
-    "symbol_table.cc",
-    "symbol_table.h",
     "utils/bitcast.h",
     "utils/bitset.h",
     "utils/block_allocator.h",
@@ -261,7 +270,10 @@
 
 libtint_source_set("libtint_clone_context_hdrs") {
   sources = [ "clone_context.h" ]
-  deps = [ ":libtint_base_src" ]
+  deps = [
+    ":libtint_symbols_src",
+    ":libtint_utils_src",
+  ]
 }
 
 libtint_source_set("libtint_program_src") {
@@ -299,11 +311,12 @@
 
   deps = [
     ":libtint_ast_hdrs",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -324,11 +337,11 @@
   ]
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_sem_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -439,11 +452,12 @@
   ]
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -472,6 +486,7 @@
     "ast/diagnostic_attribute.h",
     "ast/diagnostic_control.h",
     "ast/diagnostic_directive.h",
+    "ast/diagnostic_rule_name.h",
     "ast/disable_validation_attribute.h",
     "ast/discard_statement.h",
     "ast/enable.h",
@@ -527,10 +542,11 @@
     "ast/workgroup_attribute.h",
   ]
   deps = [
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_clone_context_hdrs",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -559,6 +575,7 @@
     "ast/diagnostic_attribute.cc",
     "ast/diagnostic_control.cc",
     "ast/diagnostic_directive.cc",
+    "ast/diagnostic_rule_name.cc",
     "ast/disable_validation_attribute.cc",
     "ast/discard_statement.cc",
     "ast/enable.cc",
@@ -613,10 +630,10 @@
   ]
   public_deps = [ ":libtint_ast_hdrs" ]
   deps = [
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -694,10 +711,11 @@
 
   deps = [
     ":libtint_ast_hdrs",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -728,7 +746,7 @@
     "builtin/texel_format.cc",
     "builtin/texel_format.h",
   ]
-  deps = [ ":libtint_base_src" ]
+  deps = [ ":libtint_utils_src" ]
 }
 
 libtint_source_set("libtint_type_src") {
@@ -799,8 +817,9 @@
   ]
 
   deps = [
-    ":libtint_base_src",
     ":libtint_builtins_src",
+    ":libtint_symbols_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -819,8 +838,9 @@
     "constant/value.h",
   ]
   deps = [
-    ":libtint_base_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -862,12 +882,13 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_reader_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     "${tint_spirv_tools_dir}/:spvtools_opt",
   ]
 
@@ -901,13 +922,13 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_inspector_src",
     ":libtint_program_src",
     ":libtint_sem_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -932,13 +953,14 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -961,11 +983,12 @@
   deps = [
     ":abseil",
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_reader_src",
+    ":libtint_symbols_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
   ]
 }
 
@@ -979,11 +1002,11 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_sem_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -998,13 +1021,14 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -1019,13 +1043,14 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -1040,13 +1065,14 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_constant_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -1061,11 +1087,11 @@
 
   deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_builtins_src",
     ":libtint_program_src",
     ":libtint_sem_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 }
@@ -1073,14 +1099,15 @@
 source_set("libtint") {
   public_deps = [
     ":libtint_ast_src",
-    ":libtint_base_src",
     ":libtint_constant_src",
     ":libtint_initializer_src",
     ":libtint_inspector_src",
     ":libtint_program_src",
     ":libtint_sem_src",
+    ":libtint_symbols_src",
     ":libtint_transform_src",
     ":libtint_type_src",
+    ":libtint_utils_src",
     ":libtint_writer_src",
   ]
 
@@ -1261,10 +1288,7 @@
       "ast/test_helper.h",
       "ast/test_helper_test.cc",
     ]
-    deps = [
-      ":libtint_ast_src",
-      ":libtint_base_src",
-    ]
+    deps = [ ":libtint_ast_src" ]
   }
 
   tint_unittests_source_set("tint_unittests_ast_src") {
@@ -1291,6 +1315,7 @@
       "ast/diagnostic_attribute_test.cc",
       "ast/diagnostic_control_test.cc",
       "ast/diagnostic_directive_test.cc",
+      "ast/diagnostic_rule_name_test.cc",
       "ast/discard_statement_test.cc",
       "ast/enable_test.cc",
       "ast/float_literal_expression_test.cc",
@@ -1329,10 +1354,10 @@
     ]
     deps = [
       ":libtint_ast_src",
-      ":libtint_base_src",
       ":libtint_builtins_src",
       ":libtint_transform_src",
       ":libtint_unittests_ast_helper",
+      ":libtint_utils_src",
     ]
 
     if (tint_build_wgsl_reader && tint_build_wgsl_writer) {
@@ -1364,7 +1389,6 @@
       "diagnostic/formatter_test.cc",
       "diagnostic/printer_test.cc",
     ]
-    deps = [ ":libtint_base_src" ]
   }
 
   tint_unittests_source_set("tint_unittests_inspector_src") {
@@ -1446,9 +1470,9 @@
       "resolver/variable_validation_test.cc",
     ]
     deps = [
-      ":libtint_base_src",
       ":libtint_builtins_src",
       ":libtint_transform_src",
+      ":libtint_utils_src",
       ":tint_unittests_ast_src",
     ]
   }
@@ -1494,10 +1518,7 @@
       "type/u32_test.cc",
       "type/vector_test.cc",
     ]
-    deps = [
-      ":libtint_base_src",
-      ":libtint_builtins_src",
-    ]
+    deps = [ ":libtint_builtins_src" ]
   }
 
   tint_unittests_source_set("tint_unittests_transform_src") {
@@ -1559,10 +1580,10 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_builtins_src",
       ":libtint_transform_src",
       ":libtint_unittests_ast_helper",
+      ":libtint_utils_src",
       ":libtint_wgsl_reader_src",
       ":libtint_wgsl_writer_src",
     ]
@@ -1570,6 +1591,9 @@
 
   tint_unittests_source_set("tint_unittests_utils_src") {
     sources = [
+      "debug_test.cc",
+      "source_test.cc",
+      "switch_test.cc",
       "utils/bitcast_test.cc",
       "utils/bitset_test.cc",
       "utils/block_allocator_test.cc",
@@ -1598,7 +1622,7 @@
       "utils/unique_vector_test.cc",
       "utils/vector_test.cc",
     ]
-    deps = [ ":libtint_base_src" ]
+    deps = [ ":libtint_utils_src" ]
   }
 
   tint_unittests_source_set("tint_unittests_writer_src") {
@@ -1610,8 +1634,8 @@
       "writer/text_generator_test.cc",
     ]
     deps = [
-      ":libtint_base_src",
       ":libtint_unittests_ast_helper",
+      ":libtint_utils_src",
       ":libtint_writer_src",
     ]
   }
@@ -1665,7 +1689,6 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_spv_reader_src",
       ":libtint_wgsl_writer_src",
       "${tint_spirv_tools_dir}/:spvtools_opt",
@@ -1710,9 +1733,9 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_builtins_src",
       ":libtint_spv_writer_src",
+      ":libtint_utils_src",
       ":tint_unittests_ast_src",
       "${tint_spirv_tools_dir}/:spvtools",
     ]
@@ -1791,7 +1814,6 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_builtins_src",
       ":libtint_unittests_ast_helper",
       ":libtint_wgsl_reader_src",
@@ -1835,6 +1857,7 @@
 
     deps = [
       ":libtint_builtins_src",
+      ":libtint_utils_src",
       ":libtint_wgsl_writer_src",
       ":tint_unittests_ast_src",
     ]
@@ -1876,6 +1899,7 @@
 
     deps = [
       ":libtint_msl_writer_src",
+      ":libtint_utils_src",
       ":tint_unittests_ast_src",
     ]
   }
@@ -1918,6 +1942,7 @@
     deps = [
       ":libtint_hlsl_writer_src",
       ":libtint_transform_src",
+      ":libtint_utils_src",
       ":tint_unittests_ast_src",
     ]
   }
@@ -1959,25 +1984,23 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_glsl_writer_src",
+      ":libtint_symbols_src",
       ":libtint_transform_src",
+      ":libtint_utils_src",
       ":tint_unittests_ast_src",
     ]
   }
 
-  tint_unittests_source_set("tint_unittests_base_src") {
+  tint_unittests_source_set("tint_unittests_symbols_src") {
     sources = [
-      "debug_test.cc",
       "number_test.cc",
       "reflection_test.cc",
       "scope_stack_test.cc",
-      "source_test.cc",
-      "switch_test.cc",
       "symbol_table_test.cc",
       "symbol_test.cc",
     ]
-    deps = [ ":libtint_base_src" ]
+    deps = [ ":libtint_symbols_src" ]
   }
 
   tint_unittests_source_set("tint_unittests_core_src") {
@@ -1988,7 +2011,6 @@
     ]
 
     deps = [
-      ":libtint_base_src",
       ":libtint_unittests_ast_helper",
       ":tint_unittests_ast_src",
     ]
@@ -2012,7 +2034,6 @@
       ":libtint_wgsl_reader_src",
       ":libtint_wgsl_writer_src",
       ":tint_unittests_ast_src",
-      ":tint_unittests_base_src",
       ":tint_unittests_builtins_src",
       ":tint_unittests_cmd_src",
       ":tint_unittests_constant_src",
@@ -2021,6 +2042,7 @@
       ":tint_unittests_inspector_src",
       ":tint_unittests_resolver_src",
       ":tint_unittests_sem_src",
+      ":tint_unittests_symbols_src",
       ":tint_unittests_transform_src",
       ":tint_unittests_type_src",
       ":tint_unittests_utils_src",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 323ed79..7bac6ed 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -126,6 +126,8 @@
   ast/diagnostic_control.h
   ast/diagnostic_directive.cc
   ast/diagnostic_directive.h
+  ast/diagnostic_rule_name.cc
+  ast/diagnostic_rule_name.h
   ast/disable_validation_attribute.cc
   ast/disable_validation_attribute.h
   ast/discard_statement.cc
@@ -845,6 +847,7 @@
     ast/diagnostic_attribute_test.cc
     ast/diagnostic_control_test.cc
     ast/diagnostic_directive_test.cc
+    ast/diagnostic_rule_name_test.cc
     ast/discard_statement_test.cc
     ast/enable_test.cc
     ast/float_literal_expression_test.cc
diff --git a/src/tint/ast/diagnostic_attribute_test.cc b/src/tint/ast/diagnostic_attribute_test.cc
index ec6ec26..a77c025 100644
--- a/src/tint/ast/diagnostic_attribute_test.cc
+++ b/src/tint/ast/diagnostic_attribute_test.cc
@@ -20,12 +20,20 @@
 using namespace tint::number_suffixes;  // NOLINT
 using DiagnosticAttributeTest = TestHelper;
 
-TEST_F(DiagnosticAttributeTest, Creation) {
-    auto* name = Ident("foo");
-    auto* d = DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, name);
+TEST_F(DiagnosticAttributeTest, Name) {
+    auto* d = DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "foo");
     EXPECT_EQ(d->Name(), "diagnostic");
     EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kWarning);
-    EXPECT_EQ(d->control.rule_name, name);
+    EXPECT_EQ(d->control.rule_name->category, nullptr);
+    CheckIdentifier(d->control.rule_name->name, "foo");
+}
+
+TEST_F(DiagnosticAttributeTest, CategoryAndName) {
+    auto* d = DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "foo", "bar");
+    EXPECT_EQ(d->Name(), "diagnostic");
+    EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kWarning);
+    CheckIdentifier(d->control.rule_name->category, "foo");
+    CheckIdentifier(d->control.rule_name->name, "bar");
 }
 
 }  // namespace
diff --git a/src/tint/ast/diagnostic_control.cc b/src/tint/ast/diagnostic_control.cc
index a2bdd46..27ec3c1 100644
--- a/src/tint/ast/diagnostic_control.cc
+++ b/src/tint/ast/diagnostic_control.cc
@@ -24,13 +24,10 @@
 
 DiagnosticControl::DiagnosticControl() = default;
 
-DiagnosticControl::DiagnosticControl(builtin::DiagnosticSeverity sev, const Identifier* rule)
+DiagnosticControl::DiagnosticControl(builtin::DiagnosticSeverity sev,
+                                     const DiagnosticRuleName* rule)
     : severity(sev), rule_name(rule) {
     TINT_ASSERT(AST, rule != nullptr);
-    if (rule) {
-        // It is invalid for a diagnostic rule name to be templated
-        TINT_ASSERT(AST, !rule->Is<TemplatedIdentifier>());
-    }
 }
 
 DiagnosticControl::DiagnosticControl(DiagnosticControl&&) = default;
diff --git a/src/tint/ast/diagnostic_control.h b/src/tint/ast/diagnostic_control.h
index f99d002..2b504e4 100644
--- a/src/tint/ast/diagnostic_control.h
+++ b/src/tint/ast/diagnostic_control.h
@@ -23,7 +23,7 @@
 
 // Forward declarations
 namespace tint::ast {
-class Identifier;
+class DiagnosticRuleName;
 }  // namespace tint::ast
 
 namespace tint::ast {
@@ -37,16 +37,16 @@
     /// Constructor
     /// @param sev the diagnostic severity
     /// @param rule the diagnostic rule name
-    DiagnosticControl(builtin::DiagnosticSeverity sev, const Identifier* rule);
+    DiagnosticControl(builtin::DiagnosticSeverity sev, const DiagnosticRuleName* rule);
 
     /// Move constructor
     DiagnosticControl(DiagnosticControl&&);
 
     /// The diagnostic severity control.
-    builtin::DiagnosticSeverity severity;
+    builtin::DiagnosticSeverity severity = builtin::DiagnosticSeverity::kUndefined;
 
     /// The diagnostic rule name.
-    const Identifier* rule_name;
+    const DiagnosticRuleName* rule_name = nullptr;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/diagnostic_control_test.cc b/src/tint/ast/diagnostic_control_test.cc
index 53afe53..d118677 100644
--- a/src/tint/ast/diagnostic_control_test.cc
+++ b/src/tint/ast/diagnostic_control_test.cc
@@ -24,12 +24,11 @@
 
 using DiagnosticControlTest = TestHelper;
 
-TEST_F(DiagnosticControlTest, Assert_RuleNotTemplated) {
+TEST_F(DiagnosticControlTest, Assert_RuleNotNull) {
     EXPECT_FATAL_FAILURE(
         {
             ProgramBuilder b;
-            DiagnosticControl control(builtin::DiagnosticSeverity::kWarning,
-                                      b.Ident("name", "a", "b", "c"));
+            DiagnosticControl control(builtin::DiagnosticSeverity::kWarning, nullptr);
         },
         "internal compiler error");
 }
diff --git a/src/tint/ast/diagnostic_directive.cc b/src/tint/ast/diagnostic_directive.cc
index f0ef041..8783901 100644
--- a/src/tint/ast/diagnostic_directive.cc
+++ b/src/tint/ast/diagnostic_directive.cc
@@ -34,4 +34,5 @@
     DiagnosticControl dc(control.severity, rule);
     return ctx->dst->create<DiagnosticDirective>(src, std::move(dc));
 }
+
 }  // namespace tint::ast
diff --git a/src/tint/ast/diagnostic_directive_test.cc b/src/tint/ast/diagnostic_directive_test.cc
index 721a545..c423ae9 100644
--- a/src/tint/ast/diagnostic_directive_test.cc
+++ b/src/tint/ast/diagnostic_directive_test.cc
@@ -21,15 +21,28 @@
 
 using DiagnosticDirectiveTest = TestHelper;
 
-TEST_F(DiagnosticDirectiveTest, Creation) {
-    auto* diag = DiagnosticDirective(Source{{{10, 5}, {10, 15}}},
-                                     builtin::DiagnosticSeverity::kWarning, "foo");
-    EXPECT_EQ(diag->source.range.begin.line, 10u);
-    EXPECT_EQ(diag->source.range.begin.column, 5u);
-    EXPECT_EQ(diag->source.range.end.line, 10u);
-    EXPECT_EQ(diag->source.range.end.column, 15u);
-    EXPECT_EQ(diag->control.severity, builtin::DiagnosticSeverity::kWarning);
-    CheckIdentifier(diag->control.rule_name, "foo");
+TEST_F(DiagnosticDirectiveTest, Name) {
+    auto* d = DiagnosticDirective(Source{{{10, 5}, {10, 15}}},
+                                  builtin::DiagnosticSeverity::kWarning, "foo");
+    EXPECT_EQ(d->source.range.begin.line, 10u);
+    EXPECT_EQ(d->source.range.begin.column, 5u);
+    EXPECT_EQ(d->source.range.end.line, 10u);
+    EXPECT_EQ(d->source.range.end.column, 15u);
+    EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kWarning);
+    EXPECT_EQ(d->control.rule_name->category, nullptr);
+    CheckIdentifier(d->control.rule_name->name, "foo");
+}
+
+TEST_F(DiagnosticDirectiveTest, CategoryAndName) {
+    auto* d = DiagnosticDirective(Source{{{10, 5}, {10, 15}}},
+                                  builtin::DiagnosticSeverity::kWarning, "foo", "bar");
+    EXPECT_EQ(d->source.range.begin.line, 10u);
+    EXPECT_EQ(d->source.range.begin.column, 5u);
+    EXPECT_EQ(d->source.range.end.line, 10u);
+    EXPECT_EQ(d->source.range.end.column, 15u);
+    EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kWarning);
+    CheckIdentifier(d->control.rule_name->category, "foo");
+    CheckIdentifier(d->control.rule_name->name, "bar");
 }
 
 }  // namespace
diff --git a/src/tint/ast/diagnostic_rule_name.cc b/src/tint/ast/diagnostic_rule_name.cc
new file mode 100644
index 0000000..856e054
--- /dev/null
+++ b/src/tint/ast/diagnostic_rule_name.cc
@@ -0,0 +1,74 @@
+// 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/diagnostic_rule_name.h"
+
+#include <string>
+
+#include "src/tint/program_builder.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ast::DiagnosticRuleName);
+
+namespace tint::ast {
+
+DiagnosticRuleName::DiagnosticRuleName(ProgramID pid,
+                                       NodeID nid,
+                                       const Source& src,
+                                       const Identifier* n)
+    : Base(pid, nid, src), name(n) {
+    TINT_ASSERT(AST, name != nullptr);
+    TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, name, program_id);
+    if (name) {
+        // It is invalid for a diagnostic rule name to be templated
+        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+    }
+}
+
+DiagnosticRuleName::DiagnosticRuleName(ProgramID pid,
+                                       NodeID nid,
+                                       const Source& src,
+                                       const Identifier* c,
+                                       const Identifier* n)
+    : Base(pid, nid, src), category(c), name(n) {
+    TINT_ASSERT(AST, name != nullptr);
+    TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, name, program_id);
+    if (name) {
+        // It is invalid for a diagnostic rule name to be templated
+        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+    }
+    if (category) {
+        TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, category, program_id);
+        // It is invalid for a diagnostic rule category to be templated
+        TINT_ASSERT(AST, !category->Is<TemplatedIdentifier>());
+    }
+}
+
+const DiagnosticRuleName* DiagnosticRuleName::Clone(CloneContext* ctx) const {
+    auto src = ctx->Clone(source);
+    auto n = ctx->Clone(name);
+    if (auto c = ctx->Clone(category)) {
+        return ctx->dst->create<DiagnosticRuleName>(src, c, n);
+    }
+    return ctx->dst->create<DiagnosticRuleName>(src, n);
+}
+
+std::string DiagnosticRuleName::String() const {
+    if (category) {
+        return category->symbol.Name() + "." + name->symbol.Name();
+    } else {
+        return name->symbol.Name();
+    }
+}
+
+}  // namespace tint::ast
diff --git a/src/tint/ast/diagnostic_rule_name.h b/src/tint/ast/diagnostic_rule_name.h
new file mode 100644
index 0000000..a3d1189
--- /dev/null
+++ b/src/tint/ast/diagnostic_rule_name.h
@@ -0,0 +1,68 @@
+// 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_DIAGNOSTIC_RULE_NAME_H_
+#define SRC_TINT_AST_DIAGNOSTIC_RULE_NAME_H_
+
+#include <string>
+
+#include "src/tint/ast/node.h"
+
+// Forward declarations
+namespace tint::ast {
+class Identifier;
+}  // namespace tint::ast
+
+namespace tint::ast {
+
+/// A diagnostic rule name used for diagnostic directives and attributes.
+class DiagnosticRuleName final : public utils::Castable<DiagnosticRuleName, Node> {
+  public:
+    /// Constructor
+    /// @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 name the rule name
+    DiagnosticRuleName(ProgramID pid, NodeID nid, const Source& src, const Identifier* name);
+
+    /// Constructor
+    /// @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 category the rule category.
+    /// @param name the rule name
+    DiagnosticRuleName(ProgramID pid,
+                       NodeID nid,
+                       const Source& src,
+                       const Identifier* category,
+                       const Identifier* name);
+
+    /// Clones this node and all transitive child nodes using the `CloneContext` `ctx`.
+    /// @param ctx the clone context
+    /// @return the newly cloned node
+    const DiagnosticRuleName* Clone(CloneContext* ctx) const override;
+
+    /// @return the full name of this diagnostic rule, either as `name` or `category.name`.
+    std::string String() const;
+
+    /// The diagnostic rule category (category.name)
+    Identifier const* const category = nullptr;
+
+    /// The diagnostic rule name.
+    Identifier const* const name;
+};
+
+}  // namespace tint::ast
+
+#endif  // SRC_TINT_AST_DIAGNOSTIC_RULE_NAME_H_
diff --git a/src/tint/ast/diagnostic_rule_name_test.cc b/src/tint/ast/diagnostic_rule_name_test.cc
new file mode 100644
index 0000000..40caac7
--- /dev/null
+++ b/src/tint/ast/diagnostic_rule_name_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string>
+
+#include "gtest/gtest-spi.h"
+#include "src/tint/ast/diagnostic_rule_name.h"
+#include "src/tint/ast/test_helper.h"
+
+namespace tint::ast {
+namespace {
+
+using DiagnosticRuleNameTest = TestHelper;
+
+TEST_F(DiagnosticRuleNameTest, String) {
+    EXPECT_EQ(DiagnosticRuleName("name")->String(), "name");
+    EXPECT_EQ(DiagnosticRuleName("category", "name")->String(), "category.name");
+}
+
+TEST_F(DiagnosticRuleNameTest, Assert_NameNotTemplated) {
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder b;
+            b.create<ast::DiagnosticRuleName>(b.Ident("name", "a", "b", "c"));
+        },
+        "internal compiler error");
+}
+
+TEST_F(DiagnosticRuleNameTest, Assert_CategoryNotTemplated) {
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder b;
+            b.create<ast::DiagnosticRuleName>(b.Ident("name"), b.Ident("category", "a", "b", "c"));
+        },
+        "internal compiler error");
+}
+
+}  // namespace
+}  // namespace tint::ast
diff --git a/src/tint/ast/module_clone_test.cc b/src/tint/ast/module_clone_test.cc
index eb7f775..b2407bc 100644
--- a/src/tint/ast/module_clone_test.cc
+++ b/src/tint/ast/module_clone_test.cc
@@ -25,7 +25,7 @@
     // Shader that exercises the bulk of the AST nodes and types.
     // See also fuzzers/tint_ast_clone_fuzzer.cc for further coverage of cloning.
     Source::File file("test.wgsl", R"(enable f16;
-diagnostic(off, chromium_unreachable_code);
+diagnostic(off, chromium.unreachable_code);
 
 struct S0 {
   @size(4)
@@ -65,7 +65,7 @@
   return 0.0;
 }
 
-@diagnostic(warning, chromium_unreachable_code)
+@diagnostic(warning, chromium.unreachable_code)
 fn f1(p0 : f32, p1 : i32) -> f32 {
   var l0 : i32 = 3;
   var l1 : f32 = 8.0;
diff --git a/src/tint/builtin/diagnostic_rule.cc b/src/tint/builtin/diagnostic_rule.cc
index 69650cb..334a88a 100644
--- a/src/tint/builtin/diagnostic_rule.cc
+++ b/src/tint/builtin/diagnostic_rule.cc
@@ -28,29 +28,45 @@
 
 namespace tint::builtin {
 
-/// ParseDiagnosticRule parses a DiagnosticRule from a string.
+/// ParseCoreDiagnosticRule parses a CoreDiagnosticRule from a string.
 /// @param str the string to parse
-/// @returns the parsed enum, or DiagnosticRule::kUndefined if the string could not be parsed.
-DiagnosticRule ParseDiagnosticRule(std::string_view str) {
-    if (str == "chromium_unreachable_code") {
-        return DiagnosticRule::kChromiumUnreachableCode;
-    }
+/// @returns the parsed enum, or CoreDiagnosticRule::kUndefined if the string could not be parsed.
+CoreDiagnosticRule ParseCoreDiagnosticRule(std::string_view str) {
     if (str == "derivative_uniformity") {
-        return DiagnosticRule::kDerivativeUniformity;
+        return CoreDiagnosticRule::kDerivativeUniformity;
     }
-    return DiagnosticRule::kUndefined;
+    return CoreDiagnosticRule::kUndefined;
 }
 
-utils::StringStream& operator<<(utils::StringStream& out, DiagnosticRule value) {
+utils::StringStream& operator<<(utils::StringStream& out, CoreDiagnosticRule value) {
     switch (value) {
-        case DiagnosticRule::kUndefined:
+        case CoreDiagnosticRule::kUndefined:
             return out << "undefined";
-        case DiagnosticRule::kChromiumUnreachableCode:
-            return out << "chromium_unreachable_code";
-        case DiagnosticRule::kDerivativeUniformity:
+        case CoreDiagnosticRule::kDerivativeUniformity:
             return out << "derivative_uniformity";
     }
     return out << "<unknown>";
 }
 
+/// ParseChromiumDiagnosticRule parses a ChromiumDiagnosticRule from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or ChromiumDiagnosticRule::kUndefined if the string could not be
+/// parsed.
+ChromiumDiagnosticRule ParseChromiumDiagnosticRule(std::string_view str) {
+    if (str == "unreachable_code") {
+        return ChromiumDiagnosticRule::kUnreachableCode;
+    }
+    return ChromiumDiagnosticRule::kUndefined;
+}
+
+utils::StringStream& operator<<(utils::StringStream& out, ChromiumDiagnosticRule value) {
+    switch (value) {
+        case ChromiumDiagnosticRule::kUndefined:
+            return out << "undefined";
+        case ChromiumDiagnosticRule::kUnreachableCode:
+            return out << "unreachable_code";
+    }
+    return out << "<unknown>";
+}
+
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/diagnostic_rule.cc.tmpl b/src/tint/builtin/diagnostic_rule.cc.tmpl
index 8705485..8e64b09 100644
--- a/src/tint/builtin/diagnostic_rule.cc.tmpl
+++ b/src/tint/builtin/diagnostic_rule.cc.tmpl
@@ -18,8 +18,12 @@
 
 namespace tint::builtin {
 
-{{ Eval "ParseEnum" (Sem.Enum "diagnostic_rule")}}
+{{ Eval "ParseEnum" (Sem.Enum "core_diagnostic_rule")}}
 
-{{ Eval "EnumOStream" (Sem.Enum "diagnostic_rule")}}
+{{ Eval "EnumOStream" (Sem.Enum "core_diagnostic_rule")}}
+
+{{ Eval "ParseEnum" (Sem.Enum "chromium_diagnostic_rule")}}
+
+{{ Eval "EnumOStream" (Sem.Enum "chromium_diagnostic_rule")}}
 
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/diagnostic_rule.h b/src/tint/builtin/diagnostic_rule.h
index 6b6d094..aa641b0 100644
--- a/src/tint/builtin/diagnostic_rule.h
+++ b/src/tint/builtin/diagnostic_rule.h
@@ -24,33 +24,56 @@
 #define SRC_TINT_BUILTIN_DIAGNOSTIC_RULE_H_
 
 #include <string>
+#include <variant>
 
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::builtin {
 
-/// The diagnostic rule.
-enum class DiagnosticRule {
+/// WGSL core diagnostic rules.
+enum class CoreDiagnosticRule {
     kUndefined,
-    kChromiumUnreachableCode,
     kDerivativeUniformity,
 };
 
 /// @param out the stream to write to
-/// @param value the DiagnosticRule
+/// @param value the CoreDiagnosticRule
 /// @returns `out` so calls can be chained
-utils::StringStream& operator<<(utils::StringStream& out, DiagnosticRule value);
+utils::StringStream& operator<<(utils::StringStream& out, CoreDiagnosticRule value);
 
-/// ParseDiagnosticRule parses a DiagnosticRule from a string.
+/// ParseCoreDiagnosticRule parses a CoreDiagnosticRule from a string.
 /// @param str the string to parse
-/// @returns the parsed enum, or DiagnosticRule::kUndefined if the string could not be parsed.
-DiagnosticRule ParseDiagnosticRule(std::string_view str);
+/// @returns the parsed enum, or CoreDiagnosticRule::kUndefined if the string could not be parsed.
+CoreDiagnosticRule ParseCoreDiagnosticRule(std::string_view str);
 
-constexpr const char* kDiagnosticRuleStrings[] = {
-    "chromium_unreachable_code",
+constexpr const char* kCoreDiagnosticRuleStrings[] = {
     "derivative_uniformity",
 };
 
+/// Chromium-specific diagnostic rules.
+enum class ChromiumDiagnosticRule {
+    kUndefined,
+    kUnreachableCode,
+};
+
+/// @param out the stream to write to
+/// @param value the ChromiumDiagnosticRule
+/// @returns `out` so calls can be chained
+utils::StringStream& operator<<(utils::StringStream& out, ChromiumDiagnosticRule value);
+
+/// ParseChromiumDiagnosticRule parses a ChromiumDiagnosticRule from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or ChromiumDiagnosticRule::kUndefined if the string could not be
+/// parsed.
+ChromiumDiagnosticRule ParseChromiumDiagnosticRule(std::string_view str);
+
+constexpr const char* kChromiumDiagnosticRuleStrings[] = {
+    "unreachable_code",
+};
+
+/// All diagnostic rules understood by Tint.
+using DiagnosticRule = std::variant<CoreDiagnosticRule, ChromiumDiagnosticRule>;
+
 }  // namespace tint::builtin
 
 #endif  // SRC_TINT_BUILTIN_DIAGNOSTIC_RULE_H_
diff --git a/src/tint/builtin/diagnostic_rule.h.tmpl b/src/tint/builtin/diagnostic_rule.h.tmpl
index ba823e3..16d7f9e 100644
--- a/src/tint/builtin/diagnostic_rule.h.tmpl
+++ b/src/tint/builtin/diagnostic_rule.h.tmpl
@@ -14,13 +14,20 @@
 #define SRC_TINT_BUILTIN_DIAGNOSTIC_RULE_H_
 
 #include <string>
+#include <variant>
 
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::builtin {
 
-/// The diagnostic rule.
-{{ Eval "DeclareEnum" (Sem.Enum "diagnostic_rule") }}
+/// WGSL core diagnostic rules.
+{{ Eval "DeclareEnum" (Sem.Enum "core_diagnostic_rule") }}
+
+/// Chromium-specific diagnostic rules.
+{{ Eval "DeclareEnum" (Sem.Enum "chromium_diagnostic_rule") }}
+
+/// All diagnostic rules understood by Tint.
+using DiagnosticRule = std::variant<CoreDiagnosticRule, ChromiumDiagnosticRule>;
 
 }  // namespace tint::builtin
 
diff --git a/src/tint/builtin/diagnostic_rule_bench.cc b/src/tint/builtin/diagnostic_rule_bench.cc
index c98bd46..fb60580 100644
--- a/src/tint/builtin/diagnostic_rule_bench.cc
+++ b/src/tint/builtin/diagnostic_rule_bench.cc
@@ -29,23 +29,36 @@
 namespace tint::builtin {
 namespace {
 
-void DiagnosticRuleParser(::benchmark::State& state) {
+void CoreDiagnosticRuleParser(::benchmark::State& state) {
     const char* kStrings[] = {
-        "chromium_unrachaccle_code",   "clromium_unreachab3_oe",    "chromium_unreachable_Vode",
-        "chromium_unreachable_code",   "chro1ium_unreachable_code", "chromium_unreJchableqqcde",
-        "chromium77unreallhable_code", "dqqrvatiHHe_uniforppity",   "deriatcv_nvformity",
-        "derivatbe_unGformity",        "derivative_uniformity",     "derivative_iinifvrmity",
-        "derivat8WWe_uniformity",      "drivaxxive_uniformity",
+        "deriative_unccformity",   "dlivative_3iformiy",    "derivative_uniforVity",
+        "derivative_uniformity",   "derivative_uniform1ty", "derivativeJunifqrmity",
+        "derivative_unifllrmit77",
     };
     for (auto _ : state) {
         for (auto* str : kStrings) {
-            auto result = ParseDiagnosticRule(str);
+            auto result = ParseCoreDiagnosticRule(str);
             benchmark::DoNotOptimize(result);
         }
     }
 }
 
-BENCHMARK(DiagnosticRuleParser);
+BENCHMARK(CoreDiagnosticRuleParser);
+
+void ChromiumDiagnosticRuleParser(::benchmark::State& state) {
+    const char* kStrings[] = {
+        "pqnreachableHHcode", "unrechcbe_cov",     "unreachGblecode",  "unreachable_code",
+        "vnriiachable_code",  "unreac8ablWW_code", "unreMchablxxcode",
+    };
+    for (auto _ : state) {
+        for (auto* str : kStrings) {
+            auto result = ParseChromiumDiagnosticRule(str);
+            benchmark::DoNotOptimize(result);
+        }
+    }
+}
+
+BENCHMARK(ChromiumDiagnosticRuleParser);
 
 }  // namespace
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/diagnostic_rule_bench.cc.tmpl b/src/tint/builtin/diagnostic_rule_bench.cc.tmpl
index 2605aae..dab6856 100644
--- a/src/tint/builtin/diagnostic_rule_bench.cc.tmpl
+++ b/src/tint/builtin/diagnostic_rule_bench.cc.tmpl
@@ -19,7 +19,9 @@
 namespace tint::builtin {
 namespace {
 
-{{ Eval "BenchmarkParseEnum" (Sem.Enum "diagnostic_rule")}}
+{{ Eval "BenchmarkParseEnum" (Sem.Enum "core_diagnostic_rule")}}
+
+{{ Eval "BenchmarkParseEnum" (Sem.Enum "chromium_diagnostic_rule")}}
 
 }  // namespace
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/diagnostic_rule_test.cc b/src/tint/builtin/diagnostic_rule_test.cc
index 9982061..78bd3f3 100644
--- a/src/tint/builtin/diagnostic_rule_test.cc
+++ b/src/tint/builtin/diagnostic_rule_test.cc
@@ -29,13 +29,13 @@
 namespace tint::builtin {
 namespace {
 
-namespace diagnostic_rule_tests {
+namespace core_diagnostic_rule_tests {
 
 namespace parse_print_tests {
 
 struct Case {
     const char* string;
-    DiagnosticRule value;
+    CoreDiagnosticRule value;
 };
 
 inline std::ostream& operator<<(std::ostream& out, Case c) {
@@ -43,43 +43,95 @@
 }
 
 static constexpr Case kValidCases[] = {
-    {"chromium_unreachable_code", DiagnosticRule::kChromiumUnreachableCode},
-    {"derivative_uniformity", DiagnosticRule::kDerivativeUniformity},
+    {"derivative_uniformity", CoreDiagnosticRule::kDerivativeUniformity},
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"chromium_unrachaccle_code", DiagnosticRule::kUndefined},
-    {"clromium_unreachab3_oe", DiagnosticRule::kUndefined},
-    {"chromium_unreachable_Vode", DiagnosticRule::kUndefined},
-    {"derivative_uniform1ty", DiagnosticRule::kUndefined},
-    {"derivativeJunifqrmity", DiagnosticRule::kUndefined},
-    {"derivative_unifllrmit77", DiagnosticRule::kUndefined},
+    {"deriative_unccformity", CoreDiagnosticRule::kUndefined},
+    {"dlivative_3iformiy", CoreDiagnosticRule::kUndefined},
+    {"derivative_uniforVity", CoreDiagnosticRule::kUndefined},
 };
 
-using DiagnosticRuleParseTest = testing::TestWithParam<Case>;
+using CoreDiagnosticRuleParseTest = testing::TestWithParam<Case>;
 
-TEST_P(DiagnosticRuleParseTest, Parse) {
+TEST_P(CoreDiagnosticRuleParseTest, Parse) {
     const char* string = GetParam().string;
-    DiagnosticRule expect = GetParam().value;
-    EXPECT_EQ(expect, ParseDiagnosticRule(string));
+    CoreDiagnosticRule expect = GetParam().value;
+    EXPECT_EQ(expect, ParseCoreDiagnosticRule(string));
 }
 
-INSTANTIATE_TEST_SUITE_P(ValidCases, DiagnosticRuleParseTest, testing::ValuesIn(kValidCases));
-INSTANTIATE_TEST_SUITE_P(InvalidCases, DiagnosticRuleParseTest, testing::ValuesIn(kInvalidCases));
+INSTANTIATE_TEST_SUITE_P(ValidCases, CoreDiagnosticRuleParseTest, testing::ValuesIn(kValidCases));
+INSTANTIATE_TEST_SUITE_P(InvalidCases,
+                         CoreDiagnosticRuleParseTest,
+                         testing::ValuesIn(kInvalidCases));
 
-using DiagnosticRulePrintTest = testing::TestWithParam<Case>;
+using CoreDiagnosticRulePrintTest = testing::TestWithParam<Case>;
 
-TEST_P(DiagnosticRulePrintTest, Print) {
-    DiagnosticRule value = GetParam().value;
+TEST_P(CoreDiagnosticRulePrintTest, Print) {
+    CoreDiagnosticRule value = GetParam().value;
     const char* expect = GetParam().string;
     EXPECT_EQ(expect, utils::ToString(value));
 }
 
-INSTANTIATE_TEST_SUITE_P(ValidCases, DiagnosticRulePrintTest, testing::ValuesIn(kValidCases));
+INSTANTIATE_TEST_SUITE_P(ValidCases, CoreDiagnosticRulePrintTest, testing::ValuesIn(kValidCases));
 
 }  // namespace parse_print_tests
 
-}  // namespace diagnostic_rule_tests
+}  // namespace core_diagnostic_rule_tests
+
+namespace chromium_diagnostic_rule_tests {
+
+namespace parse_print_tests {
+
+struct Case {
+    const char* string;
+    ChromiumDiagnosticRule value;
+};
+
+inline std::ostream& operator<<(std::ostream& out, Case c) {
+    return out << "'" << std::string(c.string) << "'";
+}
+
+static constexpr Case kValidCases[] = {
+    {"unreachable_code", ChromiumDiagnosticRule::kUnreachableCode},
+};
+
+static constexpr Case kInvalidCases[] = {
+    {"unreacha1le_code", ChromiumDiagnosticRule::kUndefined},
+    {"unreachableJcqde", ChromiumDiagnosticRule::kUndefined},
+    {"unreachable77llode", ChromiumDiagnosticRule::kUndefined},
+};
+
+using ChromiumDiagnosticRuleParseTest = testing::TestWithParam<Case>;
+
+TEST_P(ChromiumDiagnosticRuleParseTest, Parse) {
+    const char* string = GetParam().string;
+    ChromiumDiagnosticRule expect = GetParam().value;
+    EXPECT_EQ(expect, ParseChromiumDiagnosticRule(string));
+}
+
+INSTANTIATE_TEST_SUITE_P(ValidCases,
+                         ChromiumDiagnosticRuleParseTest,
+                         testing::ValuesIn(kValidCases));
+INSTANTIATE_TEST_SUITE_P(InvalidCases,
+                         ChromiumDiagnosticRuleParseTest,
+                         testing::ValuesIn(kInvalidCases));
+
+using ChromiumDiagnosticRulePrintTest = testing::TestWithParam<Case>;
+
+TEST_P(ChromiumDiagnosticRulePrintTest, Print) {
+    ChromiumDiagnosticRule value = GetParam().value;
+    const char* expect = GetParam().string;
+    EXPECT_EQ(expect, utils::ToString(value));
+}
+
+INSTANTIATE_TEST_SUITE_P(ValidCases,
+                         ChromiumDiagnosticRulePrintTest,
+                         testing::ValuesIn(kValidCases));
+
+}  // namespace parse_print_tests
+
+}  // namespace chromium_diagnostic_rule_tests
 
 }  // namespace
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/diagnostic_rule_test.cc.tmpl b/src/tint/builtin/diagnostic_rule_test.cc.tmpl
index 106f6fc..cc12bf7 100644
--- a/src/tint/builtin/diagnostic_rule_test.cc.tmpl
+++ b/src/tint/builtin/diagnostic_rule_test.cc.tmpl
@@ -19,11 +19,17 @@
 namespace tint::builtin {
 namespace {
 
-namespace diagnostic_rule_tests {
+namespace core_diagnostic_rule_tests {
 
-{{ Eval "TestParsePrintEnum" (Sem.Enum "diagnostic_rule")}}
+{{ Eval "TestParsePrintEnum" (Sem.Enum "core_diagnostic_rule")}}
 
-}  // namespace diagnostic_rule_tests
+}  // namespace core_diagnostic_rule_tests
+
+namespace chromium_diagnostic_rule_tests {
+
+{{ Eval "TestParsePrintEnum" (Sem.Enum "chromium_diagnostic_rule")}}
+
+}  // namespace chromium_diagnostic_rule_tests
 
 }  // namespace
 }  // namespace tint::builtin
diff --git a/src/tint/builtin/function.cc b/src/tint/builtin/function.cc
index 88e86b6..332e9d1 100644
--- a/src/tint/builtin/function.cc
+++ b/src/tint/builtin/function.cc
@@ -24,7 +24,7 @@
 
 namespace tint::builtin {
 
-Function ParseFunction(const std::string& name) {
+Function ParseFunction(std::string_view name) {
     if (name == "abs") {
         return Function::kAbs;
     }
diff --git a/src/tint/builtin/function.cc.tmpl b/src/tint/builtin/function.cc.tmpl
index e2729dc..7912482 100644
--- a/src/tint/builtin/function.cc.tmpl
+++ b/src/tint/builtin/function.cc.tmpl
@@ -15,7 +15,7 @@
 
 namespace tint::builtin {
 
-Function ParseFunction(const std::string& name) {
+Function ParseFunction(std::string_view name) {
 {{- range Sem.Builtins  }}
     if (name == "{{.Name}}") {
         return Function::k{{PascalCase .Name}};
diff --git a/src/tint/builtin/function.h b/src/tint/builtin/function.h
index 3ccb341..046e87a 100644
--- a/src/tint/builtin/function.h
+++ b/src/tint/builtin/function.h
@@ -153,7 +153,7 @@
 /// @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);
+Function ParseFunction(std::string_view name);
 
 /// @returns the name of the builtin function type. The spelling, including
 /// case, matches the name in the WGSL spec.
diff --git a/src/tint/builtin/function.h.tmpl b/src/tint/builtin/function.h.tmpl
index d9109bf..02f9acb 100644
--- a/src/tint/builtin/function.h.tmpl
+++ b/src/tint/builtin/function.h.tmpl
@@ -33,7 +33,7 @@
 /// @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);
+Function ParseFunction(std::string_view name);
 
 /// @returns the name of the builtin function type. The spelling, including
 /// case, matches the name in the WGSL spec.
diff --git a/src/tint/cmd/BUILD.gn b/src/tint/cmd/BUILD.gn
index 946bd36..fae4f04 100644
--- a/src/tint/cmd/BUILD.gn
+++ b/src/tint/cmd/BUILD.gn
@@ -34,7 +34,6 @@
   deps = [
     ":tint_cmd_helper",
     "${tint_root_dir}/src/tint:libtint",
-    "${tint_root_dir}/src/tint:libtint_base_src",
     "${tint_root_dir}/src/tint:tint_utils_io",
     "${tint_root_dir}/src/tint:tint_val",
     "${tint_spirv_tools_dir}/:spvtools",
@@ -65,7 +64,6 @@
   deps = [
     ":tint_cmd_helper",
     "${tint_root_dir}/src/tint:libtint",
-    "${tint_root_dir}/src/tint:libtint_base_src",
     "${tint_root_dir}/src/tint:tint_utils_io",
     "${tint_root_dir}/src/tint:tint_val",
     "${tint_spirv_tools_dir}/:spvtools",
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index fae4ee4..ee4b517 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -41,11 +41,15 @@
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#filterable-triggering-rules
-enum diagnostic_rule {
+enum core_diagnostic_rule {
   // Rules defined in the spec.
   derivative_uniformity
+}
+
+// chromium-specific diagnostics
+enum chromium_diagnostic_rule {
   // Chromium specific rules not defined in the spec.
-  chromium_unreachable_code
+  unreachable_code
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#syntax-severity_control_name
@@ -858,6 +862,9 @@
 @must_use @const("Zero") ctor f32() -> f32
 @must_use @const("Zero") ctor f16() -> f16
 @must_use @const("Zero") ctor bool() -> bool
+@must_use @const("Zero") ctor vec2() -> vec2<ia>
+@must_use @const("Zero") ctor vec3() -> vec3<ia>
+@must_use @const("Zero") ctor vec4() -> vec4<ia>
 @must_use @const("Zero") ctor vec2<T: concrete_scalar>() -> vec2<T>
 @must_use @const("Zero") ctor vec3<T: concrete_scalar>() -> vec3<T>
 @must_use @const("Zero") ctor vec4<T: concrete_scalar>() -> vec4<T>
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index b7fda95..b4f5eea 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -39,6 +39,7 @@
 #include "src/tint/ast/diagnostic_attribute.h"
 #include "src/tint/ast/diagnostic_control.h"
 #include "src/tint/ast/diagnostic_directive.h"
+#include "src/tint/ast/diagnostic_rule_name.h"
 #include "src/tint/ast/disable_validation_attribute.h"
 #include "src/tint/ast/discard_statement.h"
 #include "src/tint/ast/enable.h"
@@ -3752,57 +3753,129 @@
                                                                   validation);
     }
 
-    /// Creates an ast::DiagnosticAttribute
-    /// @param source the source information
-    /// @param severity the diagnostic severity control
-    /// @param rule_name the diagnostic rule name
-    /// @returns the diagnostic attribute pointer
+    /// Passthrough overload
+    /// @param name the diagnostic rule name
+    /// @returns @p name
+    const ast::DiagnosticRuleName* DiagnosticRuleName(const ast::DiagnosticRuleName* name) {
+        return name;
+    }
+
+    /// Creates an ast::DiagnosticRuleName
+    /// @param name the diagnostic rule name
+    /// @returns the diagnostic rule name
     template <typename NAME>
-    const ast::DiagnosticAttribute* DiagnosticAttribute(const Source& source,
-                                                        builtin::DiagnosticSeverity severity,
-                                                        NAME&& rule_name) {
+    const ast::DiagnosticRuleName* DiagnosticRuleName(NAME&& name) {
         static_assert(
             !utils::traits::IsType<utils::traits::PtrElTy<NAME>, ast::TemplatedIdentifier>,
             "it is invalid for a diagnostic rule name to be templated");
+        auto* name_ident = Ident(std::forward<NAME>(name));
+        return create<ast::DiagnosticRuleName>(name_ident->source, name_ident);
+    }
+
+    /// Creates an ast::DiagnosticRuleName
+    /// @param category the diagnostic rule category
+    /// @param name the diagnostic rule name
+    /// @returns the diagnostic rule name
+    template <typename CATEGORY, typename NAME, typename = DisableIfSource<CATEGORY>>
+    const ast::DiagnosticRuleName* DiagnosticRuleName(CATEGORY&& category, NAME&& name) {
+        static_assert(
+            !utils::traits::IsType<utils::traits::PtrElTy<NAME>, ast::TemplatedIdentifier>,
+            "it is invalid for a diagnostic rule name to be templated");
+        static_assert(
+            !utils::traits::IsType<utils::traits::PtrElTy<CATEGORY>, ast::TemplatedIdentifier>,
+            "it is invalid for a diagnostic rule category to be templated");
+        auto* category_ident = Ident(std::forward<CATEGORY>(category));
+        auto* name_ident = Ident(std::forward<NAME>(name));
+        Source source = category_ident->source;
+        source.range.end = name_ident->source.range.end;
+        return create<ast::DiagnosticRuleName>(source, category_ident, name_ident);
+    }
+
+    /// Creates an ast::DiagnosticRuleName
+    /// @param source the source information
+    /// @param name the diagnostic rule name
+    /// @returns the diagnostic rule name
+    template <typename NAME>
+    const ast::DiagnosticRuleName* DiagnosticRuleName(const Source& source, NAME&& name) {
+        static_assert(
+            !utils::traits::IsType<utils::traits::PtrElTy<NAME>, ast::TemplatedIdentifier>,
+            "it is invalid for a diagnostic rule name to be templated");
+        auto* name_ident = Ident(std::forward<NAME>(name));
+        return create<ast::DiagnosticRuleName>(source, name_ident);
+    }
+
+    /// Creates an ast::DiagnosticRuleName
+    /// @param source the source information
+    /// @param category the diagnostic rule category
+    /// @param name the diagnostic rule name
+    /// @returns the diagnostic rule name
+    template <typename CATEGORY, typename NAME>
+    const ast::DiagnosticRuleName* DiagnosticRuleName(const Source& source,
+                                                      CATEGORY&& category,
+                                                      NAME&& name) {
+        static_assert(
+            !utils::traits::IsType<utils::traits::PtrElTy<NAME>, ast::TemplatedIdentifier>,
+            "it is invalid for a diagnostic rule name to be templated");
+        static_assert(
+            !utils::traits::IsType<utils::traits::PtrElTy<CATEGORY>, ast::TemplatedIdentifier>,
+            "it is invalid for a diagnostic rule category to be templated");
+        auto* category_ident = Ident(std::forward<CATEGORY>(category));
+        auto* name_ident = Ident(std::forward<NAME>(name));
+        return create<ast::DiagnosticRuleName>(source, category_ident, name_ident);
+    }
+
+    /// Creates an ast::DiagnosticAttribute
+    /// @param source the source information
+    /// @param severity the diagnostic severity control
+    /// @param rule_args the arguments used to construct the rule name
+    /// @returns the diagnostic attribute pointer
+    template <typename... RULE_ARGS>
+    const ast::DiagnosticAttribute* DiagnosticAttribute(const Source& source,
+                                                        builtin::DiagnosticSeverity severity,
+                                                        RULE_ARGS&&... rule_args) {
         return create<ast::DiagnosticAttribute>(
-            source, ast::DiagnosticControl(severity, Ident(std::forward<NAME>(rule_name))));
+            source, ast::DiagnosticControl(
+                        severity, DiagnosticRuleName(std::forward<RULE_ARGS>(rule_args)...)));
     }
 
     /// Creates an ast::DiagnosticAttribute
     /// @param severity the diagnostic severity control
-    /// @param rule_name the diagnostic rule name
+    /// @param rule_args the arguments used to construct the rule name
     /// @returns the diagnostic attribute pointer
-    template <typename NAME>
+    template <typename... RULE_ARGS>
     const ast::DiagnosticAttribute* DiagnosticAttribute(builtin::DiagnosticSeverity severity,
-                                                        NAME&& rule_name) {
+                                                        RULE_ARGS&&... rule_args) {
         return create<ast::DiagnosticAttribute>(
-            source_, ast::DiagnosticControl(severity, Ident(std::forward<NAME>(rule_name))));
+            source_, ast::DiagnosticControl(
+                         severity, DiagnosticRuleName(std::forward<RULE_ARGS>(rule_args)...)));
     }
 
     /// Add a diagnostic directive to the module.
     /// @param source the source information
     /// @param severity the diagnostic severity control
-    /// @param rule_name the diagnostic rule name
+    /// @param rule_args the arguments used to construct the rule name
     /// @returns the diagnostic directive pointer
-    template <typename NAME>
+    template <typename... RULE_ARGS>
     const ast::DiagnosticDirective* DiagnosticDirective(const Source& source,
                                                         builtin::DiagnosticSeverity severity,
-                                                        NAME&& rule_name) {
-        auto* directive = create<ast::DiagnosticDirective>(
-            source, ast::DiagnosticControl(severity, Ident(std::forward<NAME>(rule_name))));
+                                                        RULE_ARGS&&... rule_args) {
+        auto* rule = DiagnosticRuleName(std::forward<RULE_ARGS>(rule_args)...);
+        auto* directive =
+            create<ast::DiagnosticDirective>(source, ast::DiagnosticControl(severity, rule));
         AST().AddDiagnosticDirective(directive);
         return directive;
     }
 
     /// Add a diagnostic directive to the module.
     /// @param severity the diagnostic severity control
-    /// @param rule_name the diagnostic rule name
+    /// @param rule_args the arguments used to construct the rule name
     /// @returns the diagnostic directive pointer
-    template <typename NAME>
+    template <typename... RULE_ARGS>
     const ast::DiagnosticDirective* DiagnosticDirective(builtin::DiagnosticSeverity severity,
-                                                        NAME&& rule_name) {
-        auto* directive = create<ast::DiagnosticDirective>(
-            source_, ast::DiagnosticControl(severity, Ident(std::forward<NAME>(rule_name))));
+                                                        RULE_ARGS&&... rule_args) {
+        auto* rule = DiagnosticRuleName(std::forward<RULE_ARGS>(rule_args)...);
+        auto* directive =
+            create<ast::DiagnosticDirective>(source_, ast::DiagnosticControl(severity, rule));
         AST().AddDiagnosticDirective(directive);
         return directive;
     }
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index 753f60b..514e7f8 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -72,39 +72,42 @@
 constexpr size_t const kMaxResynchronizeLookahead = 32;
 
 // https://gpuweb.github.io/gpuweb/wgsl.html#reserved-keywords
+//
+// Must be called with an identifier token.
 bool is_reserved(const Token& t) {
-    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" ||
-           t == "new" || t == "nil" || t == "noexcept" || t == "noinline" ||
-           t == "nointerpolation" || t == "noperspective" || t == "null" || t == "nullptr" ||
-           t == "of" || t == "operator" || t == "package" || t == "packoffset" ||
-           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 == "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" ||
-           t == "throw" || t == "trait" || t == "try" || t == "type" || t == "typedef" ||
-           t == "typeid" || t == "typename" || t == "typeof" || t == "union" || t == "unless" ||
-           t == "unorm" || t == "unsafe" || t == "unsized" || t == "use" || t == "using" ||
-           t == "varying" || t == "virtual" || t == "volatile" || t == "wgsl" || t == "where" ||
-           t == "with" || t == "writeonly" || t == "yield";
+    auto s = t.to_str_view();
+    return s == "NULL" || s == "Self" || s == "abstract" || s == "active" || s == "alignas" ||
+           s == "alignof" || s == "as" || s == "asm" || s == "asm_fragment" || s == "async" ||
+           s == "attribute" || s == "auto" || s == "await" || s == "become" ||
+           s == "binding_array" || s == "cast" || s == "catch" || s == "class" || s == "co_await" ||
+           s == "co_return" || s == "co_yield" || s == "coherent" || s == "column_major" ||
+           s == "common" || s == "compile" || s == "compile_fragment" || s == "concept" ||
+           s == "const_cast" || s == "consteval" || s == "constexpr" || s == "constinit" ||
+           s == "crate" || s == "debugger" || s == "decltype" || s == "delete" || s == "demote" ||
+           s == "demote_to_helper" || s == "do" || s == "dynamic_cast" || s == "enum" ||
+           s == "explicit" || s == "export" || s == "extends" || s == "extern" || s == "external" ||
+           s == "filter" || s == "final" || s == "finally" || s == "friend" || s == "from" ||
+           s == "fxgroup" || s == "get" || s == "goto" || s == "groupshared" || s == "highp" ||
+           s == "impl" || s == "implements" || s == "import" || s == "inline" ||
+           s == "instanceof" || s == "interface" || s == "layout" || s == "lowp" || s == "macro" ||
+           s == "macro_rules" || s == "match" || s == "mediump" || s == "meta" || s == "mod" ||
+           s == "module" || s == "move" || s == "mut" || s == "mutable" || s == "namespace" ||
+           s == "new" || s == "nil" || s == "noexcept" || s == "noinline" ||
+           s == "nointerpolation" || s == "noperspective" || s == "null" || s == "nullptr" ||
+           s == "of" || s == "operator" || s == "package" || s == "packoffset" ||
+           s == "partition" || s == "pass" || s == "patch" || s == "pixelfragment" ||
+           s == "precise" || s == "precision" || s == "premerge" || s == "priv" ||
+           s == "protected" || s == "pub" || s == "public" || s == "readonly" || s == "ref" ||
+           s == "regardless" || s == "register" || s == "reinterpret_cast" || s == "require" ||
+           s == "resource" || s == "restrict" || s == "self" || s == "set" || s == "shared" ||
+           s == "sizeof" || s == "smooth" || s == "snorm" || s == "static" ||
+           s == "static_assert" || s == "static_cast" || s == "std" || s == "subroutine" ||
+           s == "super" || s == "target" || s == "template" || s == "this" || s == "thread_local" ||
+           s == "throw" || s == "trait" || s == "try" || s == "type" || s == "typedef" ||
+           s == "typeid" || s == "typename" || s == "typeof" || s == "union" || s == "unless" ||
+           s == "unorm" || s == "unsafe" || s == "unsized" || s == "use" || s == "using" ||
+           s == "varying" || s == "virtual" || s == "volatile" || s == "wgsl" || s == "where" ||
+           s == "with" || s == "writeonly" || s == "yield";
 }
 
 /// Enter-exit counters for block token types.
@@ -179,10 +182,8 @@
 
 ParserImpl::TypedIdentifier::TypedIdentifier(const TypedIdentifier&) = default;
 
-ParserImpl::TypedIdentifier::TypedIdentifier(ast::Type type_in,
-                                             std::string name_in,
-                                             Source source_in)
-    : type(type_in), name(std::move(name_in)), source(std::move(source_in)) {}
+ParserImpl::TypedIdentifier::TypedIdentifier(ast::Type type_in, const ast::Identifier* name_in)
+    : type(type_in), name(name_in) {}
 
 ParserImpl::TypedIdentifier::~TypedIdentifier() = default;
 
@@ -191,7 +192,7 @@
 ParserImpl::FunctionHeader::FunctionHeader(const FunctionHeader&) = default;
 
 ParserImpl::FunctionHeader::FunctionHeader(Source src,
-                                           std::string n,
+                                           const ast::Identifier* n,
                                            utils::VectorRef<const ast::Parameter*> p,
                                            ast::Type ret_ty,
                                            utils::VectorRef<const ast::Attribute*> ret_attrs)
@@ -722,19 +723,18 @@
     }
 
     TINT_DEFER(attrs.Clear());
-
     if (is_overridable) {
-        return builder_.Override(decl->source,       // source
-                                 decl->name,         // symbol
-                                 decl->type,         // type
-                                 initializer,        // initializer
-                                 std::move(attrs));  // attributes
+        return builder_.Override(decl->name->source,  // source
+                                 decl->name,          // symbol
+                                 decl->type,          // type
+                                 initializer,         // initializer
+                                 std::move(attrs));   // attributes
     }
-    return builder_.GlobalConst(decl->source,       // source
-                                decl->name,         // symbol
-                                decl->type,         // type
-                                initializer,        // initializer
-                                std::move(attrs));  // attributes
+    return builder_.GlobalConst(decl->name->source,  // source
+                                decl->name,          // symbol
+                                decl->type,          // type
+                                initializer,         // initializer
+                                std::move(attrs));   // attributes
 }
 
 // variable_decl
@@ -762,7 +762,7 @@
         return Failure::kErrored;
     }
 
-    return VarDeclInfo{decl->source, decl->name, vq.address_space, vq.access, decl->type};
+    return VarDeclInfo{decl->name->source, decl->name, vq.address_space, vq.access, decl->type};
 }
 
 Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_with_optional_type_specifier(
@@ -774,7 +774,7 @@
     }
 
     if (allow_inferred && !peek_is(Token::Type::kColon)) {
-        return TypedIdentifier{ast::Type{}, ident.value, ident.source};
+        return TypedIdentifier{ast::Type{}, ident.value};
     }
 
     if (!expect(use, Token::Type::kColon)) {
@@ -790,7 +790,7 @@
         return add_error(t.source(), "invalid type", use);
     }
 
-    return TypedIdentifier{type.value, ident.value, ident.source};
+    return TypedIdentifier{type.value, ident.value};
 }
 
 // optionally_typed_ident
@@ -1006,7 +1006,7 @@
         return Failure::kErrored;
     }
 
-    return builder_.Member(decl->source, decl->name, decl->type, std::move(attrs.value));
+    return builder_.Member(decl->name->source, decl->name, decl->type, std::move(attrs.value));
 }
 
 // const_assert_statement
@@ -1123,8 +1123,7 @@
     }
 
     return FunctionHeader{
-        source,      std::move(name.value),        std::move(params.value),
-        return_type, std::move(return_attributes),
+        source, name.value, std::move(params.value), return_type, std::move(return_attributes),
     };
 }
 
@@ -1164,7 +1163,7 @@
         return Failure::kErrored;
     }
 
-    return builder_.Param(decl->source,             // source
+    return builder_.Param(decl->name->source,       // source
                           decl->name,               // symbol
                           decl->type,               // type
                           std::move(attrs.value));  // attributes
@@ -1446,10 +1445,10 @@
             return add_error(peek(), "missing initializer for 'const' declaration");
         }
 
-        auto* const_ = builder_.Const(typed_ident->source,  // source
-                                      typed_ident->name,    // symbol
-                                      typed_ident->type,    // type
-                                      initializer.value);   // initializer
+        auto* const_ = builder_.Const(typed_ident->name->source,  // source
+                                      typed_ident->name,          // symbol
+                                      typed_ident->type,          // type
+                                      initializer.value);         // initializer
 
         return create<ast::VariableDeclStatement>(decl_source, const_);
     }
@@ -1474,10 +1473,10 @@
             return add_error(peek(), "missing initializer for 'let' declaration");
         }
 
-        auto* let = builder_.Let(typed_ident->source,  // source
-                                 typed_ident->name,    // symbol
-                                 typed_ident->type,    // type
-                                 initializer.value);   // initializer
+        auto* let = builder_.Let(typed_ident->name->source,  // source
+                                 typed_ident->name,          // symbol
+                                 typed_ident->type,          // type
+                                 initializer.value);         // initializer
 
         return create<ast::VariableDeclStatement>(decl_source, let);
     }
@@ -2149,8 +2148,7 @@
                 return Failure::kErrored;
             }
 
-            prefix = builder_.MemberAccessor(ident.source, prefix,
-                                             builder_.Ident(ident.source, ident.value));
+            prefix = builder_.MemberAccessor(ident.source, prefix, ident.value);
             continue;
         }
 
@@ -3094,7 +3092,7 @@
 }
 
 // diagnostic_control
-// : PAREN_LEFT severity_control_name COMMA ident_pattern_token COMMA ? PAREN_RIGHT
+// : PAREN_LEFT severity_control_name COMMA diagnostic_rule_name COMMA ? PAREN_RIGHT
 Expect<ast::DiagnosticControl> ParserImpl::expect_diagnostic_control() {
     return expect_paren_block("diagnostic control", [&]() -> Expect<ast::DiagnosticControl> {
         auto severity_control = expect_severity_control_name();
@@ -3106,17 +3104,41 @@
             return Failure::kErrored;
         }
 
-        auto rule_name = expect_ident("diagnostic control");
+        auto rule_name = expect_diagnostic_rule_name();
         if (rule_name.errored) {
             return Failure::kErrored;
         }
         match(Token::Type::kComma);
 
-        return ast::DiagnosticControl(severity_control.value,
-                                      builder_.Ident(rule_name.source, rule_name.value));
+        return ast::DiagnosticControl(severity_control.value, rule_name.value);
     });
 }
 
+// diagnostic_rule_name :
+// | diagnostic_name_token
+// | diagnostic_name_token '.' diagnostic_name_token
+Expect<const ast::DiagnosticRuleName*> ParserImpl::expect_diagnostic_rule_name() {
+    if (peek_is(Token::Type::kPeriod, 1)) {
+        auto category = expect_ident("", "diagnostic rule category");
+        if (category.errored) {
+            return Failure::kErrored;
+        }
+        if (!expect("diagnostic rule", Token::Type::kPeriod)) {
+            return Failure::kErrored;
+        }
+        auto name = expect_ident("", "diagnostic rule name");
+        if (name.errored) {
+            return Failure::kErrored;
+        }
+        return builder_.DiagnosticRuleName(category.value, name.value);
+    }
+    auto name = expect_ident("", "diagnostic rule name");
+    if (name.errored) {
+        return Failure::kErrored;
+    }
+    return builder_.DiagnosticRuleName(name.value);
+}
+
 bool ParserImpl::match(Token::Type tok, Source* source /*= nullptr*/) {
     auto& t = peek();
 
@@ -3217,7 +3239,9 @@
     return {static_cast<uint32_t>(sint.value), sint.source};
 }
 
-Expect<std::string> ParserImpl::expect_ident(std::string_view use) {
+Expect<const ast::Identifier*> ParserImpl::expect_ident(
+    std::string_view use,
+    std::string_view kind /* = "identifier" */) {
     auto& t = peek();
     if (t.IsIdentifier()) {
         synchronized_ = true;
@@ -3227,13 +3251,13 @@
             return add_error(t.source(), "'" + t.to_str() + "' is a reserved keyword");
         }
 
-        return {t.to_str(), t.source()};
+        return builder_.Ident(t.source(), t.to_str());
     }
     if (handle_error(t)) {
         return Failure::kErrored;
     }
     synchronized_ = false;
-    return add_error(t.source(), "expected identifier", use);
+    return add_error(t.source(), "expected " + std::string(kind), use);
 }
 
 template <typename F, typename T>
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index 9789b4d..c7ac96d 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -211,17 +211,14 @@
         /// Constructor
         /// @param type_in parsed type
         /// @param name_in parsed identifier
-        /// @param source_in source to the identifier
-        TypedIdentifier(ast::Type type_in, std::string name_in, Source source_in);
+        TypedIdentifier(ast::Type type_in, const ast::Identifier* name_in);
         /// Destructor
         ~TypedIdentifier();
 
         /// Parsed type. type.expr be nullptr for inferred types.
         ast::Type type;
         /// Parsed identifier.
-        std::string name;
-        /// Source to the identifier.
-        Source source;
+        const ast::Identifier* name = nullptr;
     };
 
     /// FunctionHeader contains the parsed information for a function header.
@@ -238,7 +235,7 @@
         /// @param ret_ty function return type
         /// @param ret_attrs return type attributes
         FunctionHeader(Source src,
-                       std::string n,
+                       const ast::Identifier* n,
                        utils::VectorRef<const ast::Parameter*> p,
                        ast::Type ret_ty,
                        utils::VectorRef<const ast::Attribute*> ret_attrs);
@@ -252,7 +249,7 @@
         /// Parsed header source
         Source source;
         /// Function name
-        std::string name;
+        const ast::Identifier* name;
         /// Function parameters
         utils::Vector<const ast::Parameter*, 8> params;
         /// Function return type
@@ -266,7 +263,7 @@
         /// Variable declaration source
         Source source;
         /// Variable name
-        std::string name;
+        const ast::Identifier* name = nullptr;
         /// Variable address space
         const ast::Expression* address_space = nullptr;
         /// Variable access control
@@ -639,14 +636,17 @@
     /// Parses a single attribute, reporting an error if the next token does not
     /// represent a attribute.
     /// @see #attribute for the full list of attributes this method parses.
-    /// @return the parsed attribute, or nullptr on error.
+    /// @return the parsed attribute.
     Expect<const ast::Attribute*> expect_attribute();
     /// Parses a severity_control_name grammar element.
-    /// @return the parsed severity control name, or nullptr on error.
+    /// @return the parsed severity control name.
     Expect<builtin::DiagnosticSeverity> expect_severity_control_name();
     /// Parses a diagnostic_control grammar element.
-    /// @return the parsed diagnostic control, or nullptr on error.
+    /// @return the parsed diagnostic control.
     Expect<ast::DiagnosticControl> expect_diagnostic_control();
+    /// Parses a diagnostic_rule_name grammar element.
+    /// @return the parsed diagnostic rule name.
+    Expect<const ast::DiagnosticRuleName*> expect_diagnostic_rule_name();
 
     /// Splits a peekable token into to parts filling in the peekable fields.
     /// @param lhs the token to set in the current position
@@ -697,8 +697,11 @@
     /// Errors if the next token is not an identifier.
     /// Consumes the next token on match.
     /// @param use a description of what was being parsed if an error was raised
+    /// @param kind a string describing the kind of identifier.
+    ///             Examples: "identifier", "diagnostic name"
     /// @returns the parsed identifier.
-    Expect<std::string> expect_ident(std::string_view use);
+    Expect<const ast::Identifier*> expect_ident(std::string_view use,
+                                                std::string_view kind = "identifier");
     /// Parses a lexical block starting with the token `start` and ending with
     /// the token `end`. `body` is called to parse the lexical block body
     /// between the `start` and `end` tokens. If the `start` or `end` tokens
diff --git a/src/tint/reader/wgsl/parser_impl_diagnostic_attribute_test.cc b/src/tint/reader/wgsl/parser_impl_diagnostic_attribute_test.cc
index 991d5b6..69f0003 100644
--- a/src/tint/reader/wgsl/parser_impl_diagnostic_attribute_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_diagnostic_attribute_test.cc
@@ -20,7 +20,7 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, DiagnosticAttribute_Valid) {
+TEST_F(ParserImplTest, DiagnosticAttribute_Name) {
     auto p = parser("diagnostic(off, foo)");
     auto a = p->attribute();
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -30,7 +30,22 @@
     EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kOff);
     auto* r = d->control.rule_name;
     ASSERT_NE(r, nullptr);
-    ast::CheckIdentifier(r, "foo");
+    EXPECT_EQ(r->category, nullptr);
+    ast::CheckIdentifier(r->name, "foo");
+}
+
+TEST_F(ParserImplTest, DiagnosticAttribute_CategoryName) {
+    auto p = parser("diagnostic(off, foo.bar)");
+    auto a = p->attribute();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_TRUE(a.matched);
+    auto* d = a.value->As<ast::DiagnosticAttribute>();
+    ASSERT_NE(d, nullptr);
+    EXPECT_EQ(d->control.severity, builtin::DiagnosticSeverity::kOff);
+    auto* r = d->control.rule_name;
+    ASSERT_NE(r, nullptr);
+    ast::CheckIdentifier(r->category, "foo");
+    ast::CheckIdentifier(r->name, "bar");
 }
 
 }  // namespace
diff --git a/src/tint/reader/wgsl/parser_impl_diagnostic_control_test.cc b/src/tint/reader/wgsl/parser_impl_diagnostic_control_test.cc
index e45d1e7..bad434e 100644
--- a/src/tint/reader/wgsl/parser_impl_diagnostic_control_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_diagnostic_control_test.cc
@@ -23,7 +23,7 @@
 using SeverityPair = std::pair<std::string, builtin::DiagnosticSeverity>;
 class DiagnosticControlParserTest : public ParserImplTestWithParam<SeverityPair> {};
 
-TEST_P(DiagnosticControlParserTest, DiagnosticControl_Valid) {
+TEST_P(DiagnosticControlParserTest, DiagnosticControl_Name) {
     auto& params = GetParam();
     auto p = parser("(" + params.first + ", foo)");
     auto e = p->expect_diagnostic_control();
@@ -33,7 +33,21 @@
 
     auto* r = e->rule_name;
     ASSERT_NE(r, nullptr);
-    ast::CheckIdentifier(r, "foo");
+    EXPECT_EQ(r->category, nullptr);
+    ast::CheckIdentifier(r->name, "foo");
+}
+TEST_P(DiagnosticControlParserTest, DiagnosticControl_CategoryAndName) {
+    auto& params = GetParam();
+    auto p = parser("(" + params.first + ", foo.bar)");
+    auto e = p->expect_diagnostic_control();
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_EQ(e->severity, params.second);
+
+    auto* r = e->rule_name;
+    ASSERT_NE(r, nullptr);
+    ast::CheckIdentifier(r->category, "foo");
+    ast::CheckIdentifier(r->name, "bar");
 }
 INSTANTIATE_TEST_SUITE_P(DiagnosticControlParserTest,
                          DiagnosticControlParserTest,
@@ -43,7 +57,7 @@
                                          SeverityPair{"info", builtin::DiagnosticSeverity::kInfo},
                                          SeverityPair{"off", builtin::DiagnosticSeverity::kOff}));
 
-TEST_F(ParserImplTest, DiagnosticControl_Valid_TrailingComma) {
+TEST_F(ParserImplTest, DiagnosticControl_Name_TrailingComma) {
     auto p = parser("(error, foo,)");
     auto e = p->expect_diagnostic_control();
     EXPECT_FALSE(e.errored);
@@ -52,7 +66,21 @@
 
     auto* r = e->rule_name;
     ASSERT_NE(r, nullptr);
-    ast::CheckIdentifier(r, "foo");
+    EXPECT_EQ(r->category, nullptr);
+    ast::CheckIdentifier(r->name, "foo");
+}
+
+TEST_F(ParserImplTest, DiagnosticControl_CategoryAndName_TrailingComma) {
+    auto p = parser("(error, foo.bar,)");
+    auto e = p->expect_diagnostic_control();
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_EQ(e->severity, builtin::DiagnosticSeverity::kError);
+
+    auto* r = e->rule_name;
+    ASSERT_NE(r, nullptr);
+    ast::CheckIdentifier(r->category, "foo");
+    ast::CheckIdentifier(r->name, "bar");
 }
 
 TEST_F(ParserImplTest, DiagnosticControl_MissingOpenParen) {
@@ -102,7 +130,15 @@
     auto e = p->expect_diagnostic_control();
     EXPECT_TRUE(e.errored);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), R"(1:6: expected identifier for diagnostic control)");
+    EXPECT_EQ(p->error(), R"(1:6: expected diagnostic rule name)");
+}
+
+TEST_F(ParserImplTest, DiagnosticControl_MissingRuleCategory) {
+    auto p = parser("(off,for.foo)");
+    auto e = p->expect_diagnostic_control();
+    EXPECT_TRUE(e.errored);
+    EXPECT_TRUE(p->has_error());
+    EXPECT_EQ(p->error(), R"(1:6: expected diagnostic rule category)");
 }
 
 TEST_F(ParserImplTest, DiagnosticControl_InvalidRuleName) {
diff --git a/src/tint/reader/wgsl/parser_impl_diagnostic_directive_test.cc b/src/tint/reader/wgsl/parser_impl_diagnostic_directive_test.cc
index 12b69f1..a965112 100644
--- a/src/tint/reader/wgsl/parser_impl_diagnostic_directive_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_diagnostic_directive_test.cc
@@ -20,7 +20,7 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, DiagnosticDirective_Valid) {
+TEST_F(ParserImplTest, DiagnosticDirective_Name) {
     auto p = parser("diagnostic(off, foo);");
     p->diagnostic_directive();
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -33,7 +33,25 @@
 
     auto* r = directive->control.rule_name;
     ASSERT_NE(r, nullptr);
-    ast::CheckIdentifier(r, "foo");
+    EXPECT_EQ(r->category, nullptr);
+    ast::CheckIdentifier(r->name, "foo");
+}
+
+TEST_F(ParserImplTest, DiagnosticDirective_CategoryName) {
+    auto p = parser("diagnostic(off, foo.bar);");
+    p->diagnostic_directive();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    auto& ast = p->builder().AST();
+    ASSERT_EQ(ast.DiagnosticDirectives().Length(), 1u);
+    auto* directive = ast.DiagnosticDirectives()[0];
+    EXPECT_EQ(directive->control.severity, builtin::DiagnosticSeverity::kOff);
+    ASSERT_EQ(ast.GlobalDeclarations().Length(), 1u);
+    EXPECT_EQ(ast.GlobalDeclarations()[0], directive);
+
+    auto* r = directive->control.rule_name;
+    ASSERT_NE(r, nullptr);
+    ast::CheckIdentifier(r->category, "foo");
+    ast::CheckIdentifier(r->name, "bar");
 }
 
 TEST_F(ParserImplTest, DiagnosticDirective_MissingSemicolon) {
diff --git a/src/tint/reader/wgsl/parser_impl_function_header_test.cc b/src/tint/reader/wgsl/parser_impl_function_header_test.cc
index d92fef0..bfd762a 100644
--- a/src/tint/reader/wgsl/parser_impl_function_header_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_function_header_test.cc
@@ -25,7 +25,7 @@
     EXPECT_TRUE(f.matched);
     EXPECT_FALSE(f.errored);
 
-    EXPECT_EQ(f->name, "main");
+    ast::CheckIdentifier(f->name, "main");
     ASSERT_EQ(f->params.Length(), 2u);
     EXPECT_EQ(f->params[0]->name->symbol, p->builder().Symbols().Get("a"));
     EXPECT_EQ(f->params[1]->name->symbol, p->builder().Symbols().Get("b"));
@@ -38,7 +38,7 @@
     EXPECT_TRUE(f.matched);
     EXPECT_FALSE(f.errored);
 
-    EXPECT_EQ(f->name, "main");
+    ast::CheckIdentifier(f->name, "main");
     ASSERT_EQ(f->params.Length(), 1u);
     EXPECT_EQ(f->params[0]->name->symbol, p->builder().Symbols().Get("a"));
     EXPECT_EQ(f->return_type, nullptr);
@@ -51,7 +51,7 @@
     EXPECT_TRUE(f.matched);
     EXPECT_FALSE(f.errored);
 
-    EXPECT_EQ(f->name, "main");
+    ast::CheckIdentifier(f->name, "main");
     EXPECT_EQ(f->params.Length(), 0u);
     ast::CheckIdentifier(f->return_type, "f32");
     ASSERT_EQ(f->return_type_attributes.Length(), 1u);
@@ -70,7 +70,7 @@
     EXPECT_TRUE(f.matched);
     EXPECT_FALSE(f.errored);
 
-    EXPECT_EQ(f->name, "main");
+    ast::CheckIdentifier(f->name, "main");
     EXPECT_EQ(f->params.Length(), 0u);
     ast::CheckIdentifier(f->return_type, "f32");
     ASSERT_EQ(f->return_type_attributes.Length(), 1u);
diff --git a/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc b/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
index c8fb651..fb4691f 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
@@ -23,7 +23,7 @@
     EXPECT_FALSE(p->has_error());
     EXPECT_TRUE(v.matched);
     EXPECT_FALSE(v.errored);
-    EXPECT_EQ(v->name, "my_var");
+    ast::CheckIdentifier(v->name, "my_var");
     EXPECT_NE(v->type, nullptr);
 
     ast::CheckIdentifier(v->type, "f32");
@@ -43,7 +43,7 @@
     EXPECT_FALSE(p->has_error());
     EXPECT_TRUE(v.matched);
     EXPECT_FALSE(v.errored);
-    EXPECT_EQ(v->name, ident);
+    ast::CheckIdentifier(v->name, ident);
     EXPECT_NE(v->type, nullptr);
 
     ast::CheckIdentifier(v->type, "f32");
@@ -58,7 +58,7 @@
     EXPECT_FALSE(p->has_error());
     EXPECT_TRUE(v.matched);
     EXPECT_FALSE(v.errored);
-    EXPECT_EQ(v->name, "my_var");
+    ast::CheckIdentifier(v->name, "my_var");
     EXPECT_EQ(v->type, nullptr);
 
     EXPECT_EQ(v->source.range, (Source::Range{{1u, 5u}, {1u, 11u}}));
@@ -81,7 +81,7 @@
     EXPECT_TRUE(v.matched);
     EXPECT_FALSE(v.errored);
     EXPECT_FALSE(p->has_error());
-    EXPECT_EQ(v->name, "my_var");
+    ast::CheckIdentifier(v->name, "my_var");
 
     ast::CheckIdentifier(v->type, "f32");
     ast::CheckIdentifier(v->address_space, "private");
@@ -98,7 +98,7 @@
     EXPECT_TRUE(v.matched);
     EXPECT_FALSE(v.errored);
     EXPECT_FALSE(p->has_error());
-    EXPECT_EQ(v->name, "my_var");
+    ast::CheckIdentifier(v->name, "my_var");
 
     ast::CheckIdentifier(v->type, "f32");
     ast::CheckIdentifier(v->address_space, "push_constant");
diff --git a/src/tint/reader/wgsl/parser_impl_variable_ident_decl_test.cc b/src/tint/reader/wgsl/parser_impl_variable_ident_decl_test.cc
index 8de0a52..f2e70a8 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_ident_decl_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_ident_decl_test.cc
@@ -23,11 +23,11 @@
     auto decl = p->expect_ident_with_type_specifier("test");
     ASSERT_FALSE(p->has_error()) << p->error();
     ASSERT_FALSE(decl.errored);
-    ASSERT_EQ(decl->name, "my_var");
+    ast::CheckIdentifier(decl->name, "my_var");
     ASSERT_NE(decl->type, nullptr);
     ast::CheckIdentifier(decl->type, "f32");
 
-    EXPECT_EQ(decl->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
+    EXPECT_EQ(decl->name->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
     EXPECT_EQ(decl->type->source.range, (Source::Range{{1u, 10u}, {1u, 13u}}));
 }
 
@@ -36,11 +36,11 @@
     auto decl = p->expect_optionally_typed_ident("test");
     ASSERT_FALSE(p->has_error()) << p->error();
     ASSERT_FALSE(decl.errored);
-    ASSERT_EQ(decl->name, "my_var");
+    ast::CheckIdentifier(decl->name, "my_var");
     ASSERT_NE(decl->type, nullptr);
     ast::CheckIdentifier(decl->type, "f32");
 
-    EXPECT_EQ(decl->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
+    EXPECT_EQ(decl->name->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
     EXPECT_EQ(decl->type->source.range, (Source::Range{{1u, 10u}, {1u, 13u}}));
 }
 
@@ -56,10 +56,10 @@
     auto decl = p->expect_optionally_typed_ident("test");
     ASSERT_FALSE(p->has_error()) << p->error();
     ASSERT_FALSE(decl.errored);
-    ASSERT_EQ(decl->name, "my_var");
+    ast::CheckIdentifier(decl->name, "my_var");
     ASSERT_EQ(decl->type, nullptr);
 
-    EXPECT_EQ(decl->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
+    EXPECT_EQ(decl->name->source.range, (Source::Range{{1u, 1u}, {1u, 7u}}));
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent) {
diff --git a/src/tint/reader/wgsl/token.cc b/src/tint/reader/wgsl/token.cc
index e133dfc..04124e1 100644
--- a/src/tint/reader/wgsl/token.cc
+++ b/src/tint/reader/wgsl/token.cc
@@ -256,6 +256,18 @@
     }
 }
 
+std::string_view Token::to_str_view() const {
+    if (type_ != Type::kIdentifier) {
+        return {};
+    }
+
+    if (auto* view = std::get_if<std::string_view>(&value_)) {
+        return *view;
+    }
+    auto& s = std::get<std::string>(value_);
+    return {s.data(), s.length()};
+}
+
 double Token::to_f64() const {
     return std::get<double>(value_);
 }
diff --git a/src/tint/reader/wgsl/token.h b/src/tint/reader/wgsl/token.h
index 19bdd40..f7a9e0f 100644
--- a/src/tint/reader/wgsl/token.h
+++ b/src/tint/reader/wgsl/token.h
@@ -334,6 +334,10 @@
     /// Returns the string value of the token
     /// @return std::string
     std::string to_str() const;
+    /// Returns the string view of the token
+    /// @return std::string_view
+    /// @note if the token is not an identifier, an empty string_view will be returned.
+    std::string_view to_str_view() const;
     /// Returns the float value of the token. 0 is returned if the token does not
     /// contain a float value.
     /// @return double
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index d6a2f0f..098ab17 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -101,7 +101,7 @@
             return {builder.Builtin(source, builtin::BuiltinValue::kPosition)};
         case AttributeKind::kDiagnostic:
             return {builder.DiagnosticAttribute(source, builtin::DiagnosticSeverity::kInfo,
-                                                "chromium_unreachable_code")};
+                                                "chromium", "unreachable_code")};
         case AttributeKind::kGroup:
             return {builder.Group(source, 1_a)};
         case AttributeKind::kId:
diff --git a/src/tint/resolver/const_eval_binary_op_test.cc b/src/tint/resolver/const_eval_binary_op_test.cc
index 76441cd..6bf5830 100644
--- a/src/tint/resolver/const_eval_binary_op_test.cc
+++ b/src/tint/resolver/const_eval_binary_op_test.cc
@@ -1921,10 +1921,11 @@
     EXPECT_EQ(r()->error(),
               R"(12:34 error: no matching constructor for vec2<f32>(abstract-float, bool)
 
-4 candidate constructors:
+5 candidate constructors:
   vec2(x: T, y: T) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec2(T) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec2(vec2<T>) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
+  vec2() -> vec2<abstract-int>
   vec2<T>() -> vec2<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
@@ -1948,10 +1949,11 @@
     EXPECT_EQ(r()->error(),
               R"(12:34 error: no matching constructor for vec2<f32>(abstract-float, bool)
 
-4 candidate constructors:
+5 candidate constructors:
   vec2(x: T, y: T) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec2(T) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec2(vec2<T>) -> vec2<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
+  vec2() -> vec2<abstract-int>
   vec2<T>() -> vec2<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
diff --git a/src/tint/resolver/const_eval_construction_test.cc b/src/tint/resolver/const_eval_construction_test.cc
index e98d21f..361edbf 100644
--- a/src/tint/resolver/const_eval_construction_test.cc
+++ b/src/tint/resolver/const_eval_construction_test.cc
@@ -189,6 +189,9 @@
                              C<f32>(),
                              C<f16>(),
                              C<bool>(),
+                             C<builder::vec2<AInt>>(),
+                             C<builder::vec3<AInt>>(),
+                             C<builder::vec4<AInt>>(),
                              C<builder::vec3<u32>>(),
                              C<builder::vec3<i32>>(),
                              C<builder::vec3<f32>>(),
diff --git a/src/tint/resolver/dependency_graph.cc b/src/tint/resolver/dependency_graph.cc
index ec6bda7..5ba9ee2 100644
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -436,48 +436,44 @@
     void AddDependency(const ast::Identifier* from, Symbol to) {
         auto* resolved = scope_stack_.Get(to);
         if (!resolved) {
-            auto s = to.Name();
-            if (auto builtin_fn = builtin::ParseFunction(s);
-                builtin_fn != builtin::Function::kNone) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_fn));
-                return;
+            switch (to.Type()) {
+                case Symbol::BuiltinType::kNone:
+                    graph_.resolved_identifiers.Add(from, UnresolvedIdentifier{to.Name()});
+                    break;
+                case Symbol::BuiltinType::kFunction:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::Function>()));
+                    break;
+                case Symbol::BuiltinType::kBuiltin:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::Builtin>()));
+                    break;
+                case Symbol::BuiltinType::kBuiltinValue:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::BuiltinValue>()));
+                    break;
+                case Symbol::BuiltinType::kAddressSpace:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::AddressSpace>()));
+                    break;
+                case Symbol::BuiltinType::kTexelFormat:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::TexelFormat>()));
+                    break;
+                case Symbol::BuiltinType::kAccess:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::Access>()));
+                    break;
+                case Symbol::BuiltinType::kInterpolationType:
+                    graph_.resolved_identifiers.Add(
+                        from, ResolvedIdentifier(to.BuiltinValue<builtin::InterpolationType>()));
+                    break;
+                case Symbol::BuiltinType::kInterpolationSampling:
+                    graph_.resolved_identifiers.Add(
+                        from,
+                        ResolvedIdentifier(to.BuiltinValue<builtin::InterpolationSampling>()));
+                    break;
             }
-            if (auto builtin_ty = builtin::ParseBuiltin(s);
-                builtin_ty != builtin::Builtin::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_ty));
-                return;
-            }
-            if (auto builtin_val = builtin::ParseBuiltinValue(s);
-                builtin_val != builtin::BuiltinValue::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_val));
-                return;
-            }
-            if (auto addr = builtin::ParseAddressSpace(s);
-                addr != builtin::AddressSpace::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(addr));
-                return;
-            }
-            if (auto fmt = builtin::ParseTexelFormat(s); fmt != builtin::TexelFormat::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(fmt));
-                return;
-            }
-            if (auto access = builtin::ParseAccess(s); access != builtin::Access::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(access));
-                return;
-            }
-            if (auto i_type = builtin::ParseInterpolationType(s);
-                i_type != builtin::InterpolationType::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(i_type));
-                return;
-            }
-            if (auto i_smpl = builtin::ParseInterpolationSampling(s);
-                i_smpl != builtin::InterpolationSampling::kUndefined) {
-                graph_.resolved_identifiers.Add(from, ResolvedIdentifier(i_smpl));
-                return;
-            }
-
-            // Unresolved.
-            graph_.resolved_identifiers.Add(from, UnresolvedIdentifier{s});
             return;
         }
 
diff --git a/src/tint/resolver/diagnostic_control_test.cc b/src/tint/resolver/diagnostic_control_test.cc
index d7143c7..527acd1 100644
--- a/src/tint/resolver/diagnostic_control_test.cc
+++ b/src/tint/resolver/diagnostic_control_test.cc
@@ -32,7 +32,7 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_ErrorViaDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts);
@@ -42,7 +42,7 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_WarningViaDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kWarning, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kWarning, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts);
@@ -52,7 +52,7 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_InfoViaDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kInfo, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kInfo, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts);
@@ -62,7 +62,7 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_OffViaDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kOff, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kOff, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts);
@@ -73,7 +73,7 @@
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_ErrorViaAttribute) {
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts, utils::Vector{attr});
@@ -84,7 +84,7 @@
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_WarningViaAttribute) {
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts, utils::Vector{attr});
@@ -95,7 +95,7 @@
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_InfoViaAttribute) {
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kInfo, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kInfo, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts, utils::Vector{attr});
@@ -106,7 +106,7 @@
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_OffViaAttribute) {
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts, utils::Vector{attr});
@@ -116,15 +116,15 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, UnreachableCode_ErrorViaDirective_OverriddenViaAttribute) {
-    // diagnostic(error, chromium_unreachable_code);
+    // diagnostic(error, chromium.unreachable_code);
     //
-    // @diagnostic(off, chromium_unreachable_code) fn foo() {
+    // @diagnostic(off, chromium.unreachable_code) fn foo() {
     //   return;
     //   return; // Should produce a warning
     // }
-    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kWarning, "chromium", "unreachable_code");
 
     auto stmts = utils::Vector{Return(), Return()};
     Func("foo", {}, ty.void_(), stmts, utils::Vector{attr});
@@ -134,7 +134,7 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, FunctionAttributeScope) {
-    // @diagnostic(off, chromium_unreachable_code) fn foo() {
+    // @diagnostic(off, chromium.unreachable_code) fn foo() {
     //   return;
     //   return; // Should not produce a diagnostic
     // }
@@ -144,13 +144,13 @@
     //   return; // Should produce a warning (default severity)
     // }
     //
-    // @diagnostic(info, chromium_unreachable_code) fn bar() {
+    // @diagnostic(info, chromium.unreachable_code) fn bar() {
     //   return;
     //   return; // Should produce an info
     // }
     {
         auto* attr =
-            DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium_unreachable_code");
+            DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium", "unreachable_code");
         Func("foo", {}, ty.void_(),
              utils::Vector{
                  Return(),
@@ -167,7 +167,7 @@
     }
     {
         auto* attr =
-            DiagnosticAttribute(builtin::DiagnosticSeverity::kInfo, "chromium_unreachable_code");
+            DiagnosticAttribute(builtin::DiagnosticSeverity::kInfo, "chromium", "unreachable_code");
         Func("zoo", {}, ty.void_(),
              utils::Vector{
                  Return(),
@@ -182,17 +182,17 @@
 }
 
 TEST_F(ResolverDiagnosticControlTest, BlockAttributeScope) {
-    // fn foo() @diagnostic(off, chromium_unreachable_code) {
+    // fn foo() @diagnostic(off, chromium.unreachable_code) {
     //   {
     //     return;
     //     return; // Should not produce a diagnostic
     //   }
-    //   @diagnostic(warning, chromium_unreachable_code) {
-    //     if (true) @diagnostic(info, chromium_unreachable_code) {
+    //   @diagnostic(warning, chromium.unreachable_code) {
+    //     if (true) @diagnostic(info, chromium.unreachable_code) {
     //       return;
     //       return; // Should produce an info
     //     } else {
-    //       while (true) @diagnostic(off, chromium_unreachable_code) {
+    //       while (true) @diagnostic(off, chromium.unreachable_code) {
     //         return;
     //         return; // Should not produce a diagnostic
     //       }
@@ -203,7 +203,7 @@
     // }
 
     auto attr = [&](auto severity) {
-        return utils::Vector{DiagnosticAttribute(severity, "chromium_unreachable_code")};
+        return utils::Vector{DiagnosticAttribute(severity, "chromium", "unreachable_code")};
     };
     Func("foo", {}, ty.void_(),
          utils::Vector{
@@ -241,113 +241,157 @@
 78:87 warning: code is unreachable)");
 }
 
-TEST_F(ResolverDiagnosticControlTest, UnrecognizedRuleName_Directive) {
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedCoreRuleName_Directive) {
     DiagnosticDirective(builtin::DiagnosticSeverity::kError,
-                        Ident(Source{{12, 34}}, "chromium_unreachable_cod"));
+                        DiagnosticRuleName(Source{{12, 34}}, "derivative_uniform"));
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     EXPECT_EQ(r()->error(),
-              R"(12:34 warning: unrecognized diagnostic rule 'chromium_unreachable_cod'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity')");
+              R"(12:34 warning: unrecognized diagnostic rule 'derivative_uniform'
+Did you mean 'derivative_uniformity'?
+Possible values: 'derivative_uniformity')");
 }
 
-TEST_F(ResolverDiagnosticControlTest, UnrecognizedRuleName_Attribute) {
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedCoreRuleName_Attribute) {
     auto* attr = DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
-                                     Ident(Source{{12, 34}}, "chromium_unreachable_cod"));
+                                     DiagnosticRuleName(Source{{12, 34}}, "derivative_uniform"));
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     EXPECT_EQ(r()->error(),
-              R"(12:34 warning: unrecognized diagnostic rule 'chromium_unreachable_cod'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity')");
+              R"(12:34 warning: unrecognized diagnostic rule 'derivative_uniform'
+Did you mean 'derivative_uniformity'?
+Possible values: 'derivative_uniformity')");
+}
+
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedChromiumRuleName_Directive) {
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError,
+                        DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_cod"));
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+    EXPECT_EQ(r()->error(),
+              R"(12:34 warning: unrecognized diagnostic rule 'chromium.unreachable_cod'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code')");
+}
+
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedChromiumRuleName_Attribute) {
+    auto* attr =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_cod"));
+    Func("foo", {}, ty.void_(), {}, utils::Vector{attr});
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+    EXPECT_EQ(r()->error(),
+              R"(12:34 warning: unrecognized diagnostic rule 'chromium.unreachable_cod'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code')");
+}
+
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedOtherRuleName_Directive) {
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError,
+                        DiagnosticRuleName(Source{{12, 34}}, "unknown", "unreachable_cod"));
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+    EXPECT_EQ(r()->error(), "");
+}
+
+TEST_F(ResolverDiagnosticControlTest, UnrecognizedOtherRuleName_Attribute) {
+    auto* attr =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{12, 34}}, "unknown", "unreachable_cod"));
+    Func("foo", {}, ty.void_(), {}, utils::Vector{attr});
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+    EXPECT_EQ(r()->error(), "");
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameNameSameSeverity_Directive) {
     DiagnosticDirective(builtin::DiagnosticSeverity::kError,
-                        Ident(Source{{12, 34}}, "chromium_unreachable_code"));
+                        DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_code"));
     DiagnosticDirective(builtin::DiagnosticSeverity::kError,
-                        Ident(Source{{56, 78}}, "chromium_unreachable_code"));
+                        DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_code"));
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameNameDifferentSeverity_Directive) {
     DiagnosticDirective(builtin::DiagnosticSeverity::kError,
-                        Ident(Source{{12, 34}}, "chromium_unreachable_code"));
+                        DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_code"));
     DiagnosticDirective(builtin::DiagnosticSeverity::kOff,
-                        Ident(Source{{56, 78}}, "chromium_unreachable_code"));
+                        DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_code"));
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               R"(56:78 error: conflicting diagnostic directive
-12:34 note: severity of 'chromium_unreachable_code' set to 'off' here)");
+12:34 note: severity of 'chromium.unreachable_code' set to 'off' here)");
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameUnknownNameDifferentSeverity_Directive) {
     DiagnosticDirective(builtin::DiagnosticSeverity::kError,
-                        Ident(Source{{12, 34}}, "chromium_unreachable_codes"));
+                        DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_codes"));
     DiagnosticDirective(builtin::DiagnosticSeverity::kOff,
-                        Ident(Source{{56, 78}}, "chromium_unreachable_codes"));
+                        DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_codes"));
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              R"(12:34 warning: unrecognized diagnostic rule 'chromium_unreachable_codes'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity'
-56:78 warning: unrecognized diagnostic rule 'chromium_unreachable_codes'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity'
+              R"(12:34 warning: unrecognized diagnostic rule 'chromium.unreachable_codes'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code'
+56:78 warning: unrecognized diagnostic rule 'chromium.unreachable_codes'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code'
 56:78 error: conflicting diagnostic directive
-12:34 note: severity of 'chromium_unreachable_codes' set to 'off' here)");
+12:34 note: severity of 'chromium.unreachable_codes' set to 'off' here)");
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_DifferentUnknownNameDifferentSeverity_Directive) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium_unreachable_codes");
-    DiagnosticDirective(builtin::DiagnosticSeverity::kOff, "chromium_unreachable_codex");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_codes");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kOff, "chromium", "unreachable_codex");
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameNameSameSeverity_Attribute) {
-    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
-                                      Ident(Source{{12, 34}}, "chromium_unreachable_code"));
-    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
-                                      Ident(Source{{56, 78}}, "chromium_unreachable_code"));
+    auto* attr1 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_code"));
+    auto* attr2 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_code"));
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr1, attr2});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameNameDifferentSeverity_Attribute) {
-    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
-                                      Ident(Source{{12, 34}}, "chromium_unreachable_code"));
-    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff,
-                                      Ident(Source{{56, 78}}, "chromium_unreachable_code"));
+    auto* attr1 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_code"));
+    auto* attr2 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff,
+                            DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_code"));
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr1, attr2});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               R"(56:78 error: conflicting diagnostic attribute
-12:34 note: severity of 'chromium_unreachable_code' set to 'off' here)");
+12:34 note: severity of 'chromium.unreachable_code' set to 'off' here)");
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_SameUnknownNameDifferentSeverity_Attribute) {
-    auto* attr1 = DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
-                                      Ident(Source{{12, 34}}, "chromium_unreachable_codes"));
-    auto* attr2 = DiagnosticAttribute(builtin::DiagnosticSeverity::kOff,
-                                      Ident(Source{{56, 78}}, "chromium_unreachable_codes"));
+    auto* attr1 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError,
+                            DiagnosticRuleName(Source{{12, 34}}, "chromium", "unreachable_codes"));
+    auto* attr2 =
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff,
+                            DiagnosticRuleName(Source{{56, 78}}, "chromium", "unreachable_codes"));
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr1, attr2});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              R"(12:34 warning: unrecognized diagnostic rule 'chromium_unreachable_codes'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity'
-56:78 warning: unrecognized diagnostic rule 'chromium_unreachable_codes'
-Did you mean 'chromium_unreachable_code'?
-Possible values: 'chromium_unreachable_code', 'derivative_uniformity'
+              R"(12:34 warning: unrecognized diagnostic rule 'chromium.unreachable_codes'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code'
+56:78 warning: unrecognized diagnostic rule 'chromium.unreachable_codes'
+Did you mean 'chromium.unreachable_code'?
+Possible values: 'chromium.unreachable_code'
 56:78 error: conflicting diagnostic attribute
-12:34 note: severity of 'chromium_unreachable_codes' set to 'off' here)");
+12:34 note: severity of 'chromium.unreachable_codes' set to 'off' here)");
 }
 
 TEST_F(ResolverDiagnosticControlTest, Conflict_DifferentUnknownNameDifferentSeverity_Attribute) {
     auto* attr1 =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium_unreachable_codes");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_codes");
     auto* attr2 =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium_unreachable_codex");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kOff, "chromium", "unreachable_codex");
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr1, attr2});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index 6aa050b..fc226eb 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -180,6 +180,9 @@
         return numbers_[idx];
     }
 
+    /// @return the total number of type and number templates
+    size_t Count() const { return types_.Length() + numbers_.Length(); }
+
   private:
     utils::Vector<const type::Type*, 4> types_;
     utils::Vector<Number, 2> numbers_;
@@ -1589,6 +1592,7 @@
     // The overloads with the lowest score will be displayed first (top-most).
     constexpr int kMismatchedParamCountPenalty = 3;
     constexpr int kMismatchedParamTypePenalty = 2;
+    constexpr int kMismatchedTemplateCountPenalty = 1;
     constexpr int kMismatchedTemplateTypePenalty = 1;
     constexpr int kMismatchedTemplateNumberPenalty = 1;
 
@@ -1602,6 +1606,15 @@
                                                  std::min(num_parameters, num_arguments));
     }
 
+    if (score == 0) {
+        // Check that all of the template arguments provided are actually expected by the overload.
+        size_t expected_templates = overload->num_template_types + overload->num_template_numbers;
+        size_t provided_templates = in_templates.Count();
+        if (provided_templates > expected_templates) {
+            score += kMismatchedTemplateCountPenalty * (provided_templates - expected_templates);
+        }
+    }
+
     // Make a mutable copy of the input templates so we can implicitly match more templated
     // arguments.
     TemplateState templates(in_templates);
diff --git a/src/tint/resolver/intrinsic_table.inl b/src/tint/resolver/intrinsic_table.inl
index 895d489..19e9b7a 100644
--- a/src/tint/resolver/intrinsic_table.inl
+++ b/src/tint/resolver/intrinsic_table.inl
@@ -3004,83 +3004,89 @@
   /* [162] */ 52,
   /* [163] */ 0,
   /* [164] */ 11,
-  /* [165] */ 10,
+  /* [165] */ 5,
   /* [166] */ 11,
-  /* [167] */ 4,
-  /* [168] */ 12,
-  /* [169] */ 10,
+  /* [167] */ 10,
+  /* [168] */ 11,
+  /* [169] */ 4,
   /* [170] */ 12,
-  /* [171] */ 4,
-  /* [172] */ 13,
-  /* [173] */ 1,
-  /* [174] */ 13,
-  /* [175] */ 10,
+  /* [171] */ 5,
+  /* [172] */ 12,
+  /* [173] */ 10,
+  /* [174] */ 12,
+  /* [175] */ 4,
   /* [176] */ 13,
-  /* [177] */ 4,
-  /* [178] */ 14,
-  /* [179] */ 0,
-  /* [180] */ 14,
-  /* [181] */ 9,
-  /* [182] */ 14,
-  /* [183] */ 10,
-  /* [184] */ 15,
+  /* [177] */ 5,
+  /* [178] */ 13,
+  /* [179] */ 1,
+  /* [180] */ 13,
+  /* [181] */ 10,
+  /* [182] */ 13,
+  /* [183] */ 4,
+  /* [184] */ 14,
   /* [185] */ 0,
-  /* [186] */ 15,
+  /* [186] */ 14,
   /* [187] */ 9,
-  /* [188] */ 15,
+  /* [188] */ 14,
   /* [189] */ 10,
-  /* [190] */ 16,
+  /* [190] */ 15,
   /* [191] */ 0,
-  /* [192] */ 16,
+  /* [192] */ 15,
   /* [193] */ 9,
-  /* [194] */ 16,
+  /* [194] */ 15,
   /* [195] */ 10,
-  /* [196] */ 17,
+  /* [196] */ 16,
   /* [197] */ 0,
-  /* [198] */ 17,
+  /* [198] */ 16,
   /* [199] */ 9,
-  /* [200] */ 17,
+  /* [200] */ 16,
   /* [201] */ 10,
-  /* [202] */ 18,
+  /* [202] */ 17,
   /* [203] */ 0,
-  /* [204] */ 18,
+  /* [204] */ 17,
   /* [205] */ 9,
-  /* [206] */ 18,
+  /* [206] */ 17,
   /* [207] */ 10,
-  /* [208] */ 19,
+  /* [208] */ 18,
   /* [209] */ 0,
-  /* [210] */ 19,
+  /* [210] */ 18,
   /* [211] */ 9,
-  /* [212] */ 19,
+  /* [212] */ 18,
   /* [213] */ 10,
-  /* [214] */ 20,
+  /* [214] */ 19,
   /* [215] */ 0,
-  /* [216] */ 20,
+  /* [216] */ 19,
   /* [217] */ 9,
-  /* [218] */ 20,
+  /* [218] */ 19,
   /* [219] */ 10,
-  /* [220] */ 21,
+  /* [220] */ 20,
   /* [221] */ 0,
-  /* [222] */ 21,
+  /* [222] */ 20,
   /* [223] */ 9,
-  /* [224] */ 21,
+  /* [224] */ 20,
   /* [225] */ 10,
-  /* [226] */ 22,
+  /* [226] */ 21,
   /* [227] */ 0,
-  /* [228] */ 22,
+  /* [228] */ 21,
   /* [229] */ 9,
-  /* [230] */ 22,
+  /* [230] */ 21,
   /* [231] */ 10,
-  /* [232] */ 47,
+  /* [232] */ 22,
   /* [233] */ 0,
-  /* [234] */ 37,
-  /* [235] */ 38,
-  /* [236] */ 39,
-  /* [237] */ 40,
-  /* [238] */ 41,
-  /* [239] */ 46,
-  /* [240] */ 28,
-  /* [241] */ 29,
+  /* [234] */ 22,
+  /* [235] */ 9,
+  /* [236] */ 22,
+  /* [237] */ 10,
+  /* [238] */ 47,
+  /* [239] */ 0,
+  /* [240] */ 37,
+  /* [241] */ 38,
+  /* [242] */ 39,
+  /* [243] */ 40,
+  /* [244] */ 41,
+  /* [245] */ 46,
+  /* [246] */ 28,
+  /* [247] */ 29,
 };
 
 // Assert that the MatcherIndex is big enough to index all the matchers, plus
@@ -3423,7 +3429,7 @@
   {
     /* [66] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [67] */
@@ -3463,7 +3469,7 @@
   {
     /* [74] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [75] */
@@ -3483,12 +3489,12 @@
   {
     /* [78] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [79] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [80] */
@@ -3518,7 +3524,7 @@
   {
     /* [85] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [86] */
@@ -3543,12 +3549,12 @@
   {
     /* [90] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [91] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [92] */
@@ -3573,12 +3579,12 @@
   {
     /* [96] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [97] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [98] */
@@ -3608,7 +3614,7 @@
   {
     /* [103] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [104] */
@@ -3638,7 +3644,7 @@
   {
     /* [109] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [110] */
@@ -3668,7 +3674,7 @@
   {
     /* [115] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [116] */
@@ -3698,7 +3704,7 @@
   {
     /* [121] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [122] */
@@ -3728,7 +3734,7 @@
   {
     /* [127] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [128] */
@@ -3753,12 +3759,12 @@
   {
     /* [132] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [133] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [134] */
@@ -3853,7 +3859,7 @@
   {
     /* [152] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [153] */
@@ -3878,7 +3884,7 @@
   {
     /* [157] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [158] */
@@ -3903,7 +3909,7 @@
   {
     /* [162] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [163] */
@@ -3918,12 +3924,12 @@
   {
     /* [165] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [166] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [167] */
@@ -3943,12 +3949,12 @@
   {
     /* [170] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [171] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [172] */
@@ -3968,12 +3974,12 @@
   {
     /* [175] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [176] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [177] */
@@ -3993,12 +3999,12 @@
   {
     /* [180] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [181] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [182] */
@@ -4023,7 +4029,7 @@
   {
     /* [186] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [187] */
@@ -4043,12 +4049,12 @@
   {
     /* [190] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [191] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [192] */
@@ -4073,7 +4079,7 @@
   {
     /* [196] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [197] */
@@ -4098,7 +4104,7 @@
   {
     /* [201] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [202] */
@@ -4123,7 +4129,7 @@
   {
     /* [206] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [207] */
@@ -4148,7 +4154,7 @@
   {
     /* [211] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [212] */
@@ -4168,12 +4174,12 @@
   {
     /* [215] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [216] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [217] */
@@ -4193,12 +4199,12 @@
   {
     /* [220] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [221] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [222] */
@@ -4218,12 +4224,12 @@
   {
     /* [225] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [226] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [227] */
@@ -4243,12 +4249,12 @@
   {
     /* [230] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [231] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [232] */
@@ -4268,12 +4274,12 @@
   {
     /* [235] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [236] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [237] */
@@ -4293,12 +4299,12 @@
   {
     /* [240] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [241] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [242] */
@@ -4323,7 +4329,7 @@
   {
     /* [246] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [247] */
@@ -4348,7 +4354,7 @@
   {
     /* [251] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [252] */
@@ -4373,7 +4379,7 @@
   {
     /* [256] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [257] */
@@ -4398,7 +4404,7 @@
   {
     /* [261] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [262] */
@@ -4423,7 +4429,7 @@
   {
     /* [266] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [267] */
@@ -4448,7 +4454,7 @@
   {
     /* [271] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [272] */
@@ -4473,7 +4479,7 @@
   {
     /* [276] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [277] */
@@ -4493,12 +4499,12 @@
   {
     /* [280] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [281] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [282] */
@@ -4518,12 +4524,12 @@
   {
     /* [285] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [286] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [287] */
@@ -4543,12 +4549,12 @@
   {
     /* [290] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [291] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [292] */
@@ -4618,7 +4624,7 @@
   {
     /* [305] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [306] */
@@ -4638,7 +4644,7 @@
   {
     /* [309] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [310] */
@@ -4648,12 +4654,12 @@
   {
     /* [311] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [312] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [313] */
@@ -4668,12 +4674,12 @@
   {
     /* [315] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [316] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [317] */
@@ -4688,12 +4694,12 @@
   {
     /* [319] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [320] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [321] */
@@ -4708,12 +4714,12 @@
   {
     /* [323] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [324] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [325] */
@@ -4728,12 +4734,12 @@
   {
     /* [327] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [328] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [329] */
@@ -4753,7 +4759,7 @@
   {
     /* [332] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [333] */
@@ -4773,7 +4779,7 @@
   {
     /* [336] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [337] */
@@ -4793,7 +4799,7 @@
   {
     /* [340] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [341] */
@@ -4813,7 +4819,7 @@
   {
     /* [344] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [345] */
@@ -4828,12 +4834,12 @@
   {
     /* [347] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [348] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [349] */
@@ -4848,12 +4854,12 @@
   {
     /* [351] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [352] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [353] */
@@ -4868,12 +4874,12 @@
   {
     /* [355] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [356] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [357] */
@@ -4893,7 +4899,7 @@
   {
     /* [360] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [361] */
@@ -4913,7 +4919,7 @@
   {
     /* [364] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [365] */
@@ -4933,7 +4939,7 @@
   {
     /* [368] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [369] */
@@ -4948,12 +4954,12 @@
   {
     /* [371] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [372] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [373] */
@@ -4968,12 +4974,12 @@
   {
     /* [375] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [376] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [377] */
@@ -4988,12 +4994,12 @@
   {
     /* [379] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [380] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [381] */
@@ -5008,12 +5014,12 @@
   {
     /* [383] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [384] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[241],
+    /* matcher indices */ &kMatcherIndices[247],
   },
   {
     /* [385] */
@@ -5033,7 +5039,7 @@
   {
     /* [388] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [389] */
@@ -5053,7 +5059,7 @@
   {
     /* [392] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [393] */
@@ -5073,7 +5079,7 @@
   {
     /* [396] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [397] */
@@ -5088,12 +5094,12 @@
   {
     /* [399] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [400] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [401] */
@@ -5108,12 +5114,12 @@
   {
     /* [403] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [404] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [405] */
@@ -5208,7 +5214,7 @@
   {
     /* [423] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [424] */
@@ -5568,12 +5574,12 @@
   {
     /* [495] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [496] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [497] */
@@ -5583,12 +5589,12 @@
   {
     /* [498] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [499] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [500] */
@@ -5603,7 +5609,7 @@
   {
     /* [502] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [503] */
@@ -5618,7 +5624,7 @@
   {
     /* [505] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [506] */
@@ -5633,7 +5639,7 @@
   {
     /* [508] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [509] */
@@ -5648,7 +5654,7 @@
   {
     /* [511] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [512] */
@@ -5658,12 +5664,12 @@
   {
     /* [513] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [514] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [515] */
@@ -5673,12 +5679,12 @@
   {
     /* [516] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [517] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [518] */
@@ -5693,7 +5699,7 @@
   {
     /* [520] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [521] */
@@ -5703,12 +5709,12 @@
   {
     /* [522] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[239],
+    /* matcher indices */ &kMatcherIndices[245],
   },
   {
     /* [523] */
     /* usage */ ParameterUsage::kSampler,
-    /* matcher indices */ &kMatcherIndices[240],
+    /* matcher indices */ &kMatcherIndices[246],
   },
   {
     /* [524] */
@@ -5913,7 +5919,7 @@
   {
     /* [564] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [565] */
@@ -5928,7 +5934,7 @@
   {
     /* [567] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[238],
+    /* matcher indices */ &kMatcherIndices[244],
   },
   {
     /* [568] */
@@ -6313,7 +6319,7 @@
   {
     /* [644] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [645] */
@@ -6323,7 +6329,7 @@
   {
     /* [646] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [647] */
@@ -6333,7 +6339,7 @@
   {
     /* [648] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [649] */
@@ -6343,7 +6349,7 @@
   {
     /* [650] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [651] */
@@ -6353,7 +6359,7 @@
   {
     /* [652] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[239],
+    /* matcher indices */ &kMatcherIndices[245],
   },
   {
     /* [653] */
@@ -7693,27 +7699,27 @@
   {
     /* [920] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [921] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [922] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [923] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [924] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[238],
+    /* matcher indices */ &kMatcherIndices[244],
   },
   {
     /* [925] */
@@ -7738,7 +7744,7 @@
   {
     /* [929] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[239],
+    /* matcher indices */ &kMatcherIndices[245],
   },
   {
     /* [930] */
@@ -7753,12 +7759,12 @@
   {
     /* [932] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [933] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [934] */
@@ -7798,22 +7804,22 @@
   {
     /* [941] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[234],
+    /* matcher indices */ &kMatcherIndices[240],
   },
   {
     /* [942] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[235],
+    /* matcher indices */ &kMatcherIndices[241],
   },
   {
     /* [943] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[236],
+    /* matcher indices */ &kMatcherIndices[242],
   },
   {
     /* [944] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[237],
+    /* matcher indices */ &kMatcherIndices[243],
   },
   {
     /* [945] */
@@ -7823,7 +7829,7 @@
   {
     /* [946] */
     /* usage */ ParameterUsage::kTexture,
-    /* matcher indices */ &kMatcherIndices[238],
+    /* matcher indices */ &kMatcherIndices[244],
   },
   {
     /* [947] */
@@ -7998,162 +8004,162 @@
   {
     /* [981] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [982] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [983] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [984] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [985] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[172],
+    /* matcher indices */ &kMatcherIndices[178],
   },
   {
     /* [986] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[178],
+    /* matcher indices */ &kMatcherIndices[184],
   },
   {
     /* [987] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[180],
+    /* matcher indices */ &kMatcherIndices[186],
   },
   {
     /* [988] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[182],
+    /* matcher indices */ &kMatcherIndices[188],
   },
   {
     /* [989] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[184],
+    /* matcher indices */ &kMatcherIndices[190],
   },
   {
     /* [990] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[186],
+    /* matcher indices */ &kMatcherIndices[192],
   },
   {
     /* [991] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[188],
+    /* matcher indices */ &kMatcherIndices[194],
   },
   {
     /* [992] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[190],
+    /* matcher indices */ &kMatcherIndices[196],
   },
   {
     /* [993] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[192],
+    /* matcher indices */ &kMatcherIndices[198],
   },
   {
     /* [994] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[194],
+    /* matcher indices */ &kMatcherIndices[200],
   },
   {
     /* [995] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[196],
+    /* matcher indices */ &kMatcherIndices[202],
   },
   {
     /* [996] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[198],
+    /* matcher indices */ &kMatcherIndices[204],
   },
   {
     /* [997] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[200],
+    /* matcher indices */ &kMatcherIndices[206],
   },
   {
     /* [998] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[202],
+    /* matcher indices */ &kMatcherIndices[208],
   },
   {
     /* [999] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[204],
+    /* matcher indices */ &kMatcherIndices[210],
   },
   {
     /* [1000] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[206],
+    /* matcher indices */ &kMatcherIndices[212],
   },
   {
     /* [1001] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[208],
+    /* matcher indices */ &kMatcherIndices[214],
   },
   {
     /* [1002] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[210],
+    /* matcher indices */ &kMatcherIndices[216],
   },
   {
     /* [1003] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[212],
+    /* matcher indices */ &kMatcherIndices[218],
   },
   {
     /* [1004] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[214],
+    /* matcher indices */ &kMatcherIndices[220],
   },
   {
     /* [1005] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[216],
+    /* matcher indices */ &kMatcherIndices[222],
   },
   {
     /* [1006] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[218],
+    /* matcher indices */ &kMatcherIndices[224],
   },
   {
     /* [1007] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[220],
+    /* matcher indices */ &kMatcherIndices[226],
   },
   {
     /* [1008] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[222],
+    /* matcher indices */ &kMatcherIndices[228],
   },
   {
     /* [1009] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[224],
+    /* matcher indices */ &kMatcherIndices[230],
   },
   {
     /* [1010] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[226],
+    /* matcher indices */ &kMatcherIndices[232],
   },
   {
     /* [1011] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[228],
+    /* matcher indices */ &kMatcherIndices[234],
   },
   {
     /* [1012] */
     /* usage */ ParameterUsage::kNone,
-    /* matcher indices */ &kMatcherIndices[230],
+    /* matcher indices */ &kMatcherIndices[236],
   },
   {
     /* [1013] */
@@ -8735,186 +8741,18 @@
   },
   {
     /* [27] */
-    /* num parameters */ 3,
+    /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[501],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[176],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [28] */
-    /* num parameters */ 3,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[504],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [29] */
-    /* num parameters */ 4,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[331],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [30] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[335],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [31] */
-    /* num parameters */ 5,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[185],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [32] */
-    /* num parameters */ 3,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[507],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [33] */
-    /* num parameters */ 4,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[339],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [34] */
-    /* num parameters */ 3,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[510],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [35] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[343],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [36] */
-    /* num parameters */ 3,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[513],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [37] */
-    /* num parameters */ 4,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[347],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [38] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[351],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [39] */
-    /* num parameters */ 5,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[190],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [40] */
-    /* num parameters */ 3,
-    /* num template types */ 0,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[38],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[516],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [41] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[2],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[355],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [42] */
     /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8926,7 +8764,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [43] */
+    /* [29] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8938,7 +8776,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [44] */
+    /* [30] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8950,7 +8788,7 @@
     /* const eval */ &ConstEval::VecSplat,
   },
   {
-    /* [45] */
+    /* [31] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8962,7 +8800,7 @@
     /* const eval */ &ConstEval::VecInitS,
   },
   {
-    /* [46] */
+    /* [32] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8974,7 +8812,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [47] */
+    /* [33] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8986,7 +8824,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [48] */
+    /* [34] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -8998,7 +8836,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [49] */
+    /* [35] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9010,7 +8848,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [50] */
+    /* [36] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9022,7 +8860,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [51] */
+    /* [37] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9034,7 +8872,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [52] */
+    /* [38] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9046,19 +8884,19 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [53] */
+    /* [39] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[982],
-    /* return matcher indices */ &kMatcherIndices[174],
+    /* return matcher indices */ &kMatcherIndices[180],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [54] */
+    /* [40] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9070,7 +8908,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [55] */
+    /* [41] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9082,20 +8920,200 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [56] */
+    /* [42] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[985],
-    /* return matcher indices */ &kMatcherIndices[176],
+    /* return matcher indices */ &kMatcherIndices[182],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
+    /* [43] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[501],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [44] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[504],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [45] */
+    /* num parameters */ 4,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[331],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [46] */
+    /* num parameters */ 4,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[335],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [47] */
+    /* num parameters */ 5,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[185],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [48] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[507],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [49] */
+    /* num parameters */ 4,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[339],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [50] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[510],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [51] */
+    /* num parameters */ 4,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[343],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [52] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[513],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [53] */
+    /* num parameters */ 4,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[347],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [54] */
+    /* num parameters */ 4,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[351],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [55] */
+    /* num parameters */ 5,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[190],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [56] */
+    /* num parameters */ 3,
+    /* num template types */ 0,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[38],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[516],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
     /* [57] */
     /* num parameters */ 4,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[2],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[355],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [58] */
+    /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[38],
@@ -9106,7 +9124,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [58] */
+    /* [59] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9118,7 +9136,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [59] */
+    /* [60] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9130,7 +9148,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [60] */
+    /* [61] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9142,7 +9160,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [61] */
+    /* [62] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9154,7 +9172,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [62] */
+    /* [63] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9166,7 +9184,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [63] */
+    /* [64] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9178,7 +9196,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [64] */
+    /* [65] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9190,7 +9208,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [65] */
+    /* [66] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9202,7 +9220,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [66] */
+    /* [67] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9214,7 +9232,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [67] */
+    /* [68] */
     /* num parameters */ 5,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9226,7 +9244,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [68] */
+    /* [69] */
     /* num parameters */ 6,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9238,7 +9256,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [69] */
+    /* [70] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9250,7 +9268,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [70] */
+    /* [71] */
     /* num parameters */ 5,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9262,7 +9280,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [71] */
+    /* [72] */
     /* num parameters */ 4,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9274,7 +9292,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [72] */
+    /* [73] */
     /* num parameters */ 5,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9286,7 +9304,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [73] */
+    /* [74] */
     /* num parameters */ 5,
     /* num template types */ 3,
     /* num template numbers */ 0,
@@ -9298,7 +9316,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [74] */
+    /* [75] */
     /* num parameters */ 6,
     /* num template types */ 3,
     /* num template numbers */ 0,
@@ -9310,7 +9328,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [75] */
+    /* [76] */
     /* num parameters */ 4,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9322,7 +9340,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [76] */
+    /* [77] */
     /* num parameters */ 5,
     /* num template types */ 3,
     /* num template numbers */ 0,
@@ -9334,7 +9352,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [77] */
+    /* [78] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9346,7 +9364,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [78] */
+    /* [79] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9358,7 +9376,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [79] */
+    /* [80] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9370,7 +9388,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [80] */
+    /* [81] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9382,7 +9400,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [81] */
+    /* [82] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9394,7 +9412,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [82] */
+    /* [83] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9406,7 +9424,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [83] */
+    /* [84] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9418,7 +9436,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [84] */
+    /* [85] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9430,7 +9448,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [85] */
+    /* [86] */
     /* num parameters */ 4,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9442,7 +9460,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [86] */
+    /* [87] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9454,7 +9472,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [87] */
+    /* [88] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9466,7 +9484,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [88] */
+    /* [89] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9478,7 +9496,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [89] */
+    /* [90] */
     /* num parameters */ 4,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9490,7 +9508,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [90] */
+    /* [91] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9502,7 +9520,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [91] */
+    /* [92] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9514,7 +9532,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [92] */
+    /* [93] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9526,7 +9544,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [93] */
+    /* [94] */
     /* num parameters */ 4,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9538,7 +9556,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [94] */
+    /* [95] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9550,7 +9568,19 @@
     /* const eval */ nullptr,
   },
   {
-    /* [95] */
+    /* [96] */
+    /* 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[170],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Zero,
+  },
+  {
+    /* [97] */
     /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9562,7 +9592,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [96] */
+    /* [98] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9574,7 +9604,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [97] */
+    /* [99] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9586,7 +9616,7 @@
     /* const eval */ &ConstEval::VecSplat,
   },
   {
-    /* [98] */
+    /* [100] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9598,7 +9628,7 @@
     /* const eval */ &ConstEval::VecInitS,
   },
   {
-    /* [99] */
+    /* [101] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9610,7 +9640,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [100] */
+    /* [102] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9622,7 +9652,7 @@
     /* const eval */ &ConstEval::VecInitM,
   },
   {
-    /* [101] */
+    /* [103] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9634,19 +9664,19 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [102] */
+    /* [104] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[975],
-    /* return matcher indices */ &kMatcherIndices[168],
+    /* return matcher indices */ &kMatcherIndices[172],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [103] */
+    /* [105] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9658,7 +9688,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [104] */
+    /* [106] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -9670,19 +9700,19 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [105] */
+    /* [107] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[978],
-    /* return matcher indices */ &kMatcherIndices[170],
+    /* return matcher indices */ &kMatcherIndices[174],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [106] */
+    /* [108] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9694,7 +9724,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [107] */
+    /* [109] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9706,7 +9736,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [108] */
+    /* [110] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9718,7 +9748,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [109] */
+    /* [111] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9730,7 +9760,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [110] */
+    /* [112] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9742,7 +9772,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [111] */
+    /* [113] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -9754,7 +9784,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [112] */
+    /* [114] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9766,7 +9796,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [113] */
+    /* [115] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9778,7 +9808,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [114] */
+    /* [116] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9790,7 +9820,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [115] */
+    /* [117] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -9802,223 +9832,19 @@
     /* const eval */ nullptr,
   },
   {
-    /* [116] */
-    /* num parameters */ 3,
-    /* num template types */ 3,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[4],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[552],
-    /* return matcher indices */ &kMatcherIndices[134],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [117] */
-    /* num parameters */ 3,
-    /* num template types */ 3,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[4],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[555],
-    /* return matcher indices */ &kMatcherIndices[134],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
     /* [118] */
-    /* num parameters */ 4,
-    /* num template types */ 4,
+    /* num parameters */ 0,
+    /* num template types */ 0,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[0],
+    /* template types */ &kTemplateTypes[38],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[419],
-    /* return matcher indices */ &kMatcherIndices[134],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[164],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [119] */
-    /* num parameters */ 3,
-    /* num template types */ 3,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[4],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[558],
-    /* return matcher indices */ &kMatcherIndices[134],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [120] */
-    /* num parameters */ 3,
-    /* num template types */ 3,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[7],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[561],
-    /* return matcher indices */ &kMatcherIndices[134],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [121] */
-    /* num parameters */ 3,
-    /* num template types */ 2,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[5],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[564],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [122] */
-    /* num parameters */ 4,
-    /* num template types */ 3,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[1],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[423],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [123] */
-    /* num parameters */ 3,
-    /* num template types */ 2,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[8],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[567],
-    /* return matcher indices */ &kMatcherIndices[42],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [124] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[1],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[652],
-    /* return matcher indices */ &kMatcherIndices[114],
-    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ nullptr,
-  },
-  {
-    /* [125] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[692],
-    /* return matcher indices */ &kMatcherIndices[3],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [126] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[694],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [127] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[696],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [128] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 1,
-    /* template types */ &kTemplateTypes[24],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[698],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [129] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[700],
-    /* return matcher indices */ &kMatcherIndices[14],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [130] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[4],
-    /* parameters */ &kParameters[702],
-    /* return matcher indices */ &kMatcherIndices[14],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiply,
-  },
-  {
-    /* [131] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[1],
-    /* parameters */ &kParameters[704],
-    /* return matcher indices */ &kMatcherIndices[100],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiplyMatVec,
-  },
-  {
-    /* [132] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 2,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[1],
-    /* parameters */ &kParameters[706],
-    /* return matcher indices */ &kMatcherIndices[34],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiplyVecMat,
-  },
-  {
-    /* [133] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 3,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[0],
-    /* parameters */ &kParameters[708],
-    /* return matcher indices */ &kMatcherIndices[30],
-    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::OpMultiplyMatMat,
-  },
-  {
-    /* [134] */
     /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10030,7 +9856,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [135] */
+    /* [120] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10042,7 +9868,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [136] */
+    /* [121] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10054,7 +9880,7 @@
     /* const eval */ &ConstEval::VecSplat,
   },
   {
-    /* [137] */
+    /* [122] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10066,7 +9892,7 @@
     /* const eval */ &ConstEval::VecInitS,
   },
   {
-    /* [138] */
+    /* [123] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -10078,19 +9904,19 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [139] */
+    /* [124] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[968],
-    /* return matcher indices */ &kMatcherIndices[164],
+    /* return matcher indices */ &kMatcherIndices[166],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [140] */
+    /* [125] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -10102,7 +9928,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [141] */
+    /* [126] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -10114,19 +9940,235 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [142] */
+    /* [127] */
     /* num parameters */ 1,
     /* num template types */ 2,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[22],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[971],
-    /* return matcher indices */ &kMatcherIndices[166],
+    /* return matcher indices */ &kMatcherIndices[168],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
+    /* [128] */
+    /* num parameters */ 3,
+    /* num template types */ 3,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[4],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[552],
+    /* return matcher indices */ &kMatcherIndices[134],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [129] */
+    /* num parameters */ 3,
+    /* num template types */ 3,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[4],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[555],
+    /* return matcher indices */ &kMatcherIndices[134],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [130] */
+    /* num parameters */ 4,
+    /* num template types */ 4,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[0],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[419],
+    /* return matcher indices */ &kMatcherIndices[134],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [131] */
+    /* num parameters */ 3,
+    /* num template types */ 3,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[4],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[558],
+    /* return matcher indices */ &kMatcherIndices[134],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [132] */
+    /* num parameters */ 3,
+    /* num template types */ 3,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[7],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[561],
+    /* return matcher indices */ &kMatcherIndices[134],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [133] */
+    /* num parameters */ 3,
+    /* num template types */ 2,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[5],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[564],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [134] */
+    /* num parameters */ 4,
+    /* num template types */ 3,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[1],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[423],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [135] */
+    /* num parameters */ 3,
+    /* num template types */ 2,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[8],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[567],
+    /* return matcher indices */ &kMatcherIndices[42],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [136] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[1],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[652],
+    /* return matcher indices */ &kMatcherIndices[114],
+    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ nullptr,
+  },
+  {
+    /* [137] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[692],
+    /* return matcher indices */ &kMatcherIndices[3],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
+    /* [138] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[694],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
+    /* [139] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[696],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
+    /* [140] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 1,
+    /* template types */ &kTemplateTypes[24],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[698],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
+    /* [141] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[700],
+    /* return matcher indices */ &kMatcherIndices[14],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
+    /* [142] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[4],
+    /* parameters */ &kParameters[702],
+    /* return matcher indices */ &kMatcherIndices[14],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiply,
+  },
+  {
     /* [143] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[1],
+    /* parameters */ &kParameters[704],
+    /* return matcher indices */ &kMatcherIndices[100],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiplyMatVec,
+  },
+  {
+    /* [144] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 2,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[1],
+    /* parameters */ &kParameters[706],
+    /* return matcher indices */ &kMatcherIndices[34],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiplyVecMat,
+  },
+  {
+    /* [145] */
+    /* num parameters */ 2,
+    /* num template types */ 1,
+    /* num template numbers */ 3,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[0],
+    /* parameters */ &kParameters[708],
+    /* return matcher indices */ &kMatcherIndices[30],
+    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::OpMultiplyMatMat,
+  },
+  {
+    /* [146] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10138,7 +10180,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [144] */
+    /* [147] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10150,7 +10192,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [145] */
+    /* [148] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10162,7 +10204,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [146] */
+    /* [149] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10174,7 +10216,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [147] */
+    /* [150] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10186,7 +10228,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [148] */
+    /* [151] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10198,7 +10240,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [149] */
+    /* [152] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10210,7 +10252,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [150] */
+    /* [153] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10222,7 +10264,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [151] */
+    /* [154] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10234,7 +10276,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [152] */
+    /* [155] */
     /* num parameters */ 6,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10246,7 +10288,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [153] */
+    /* [156] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10258,7 +10300,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [154] */
+    /* [157] */
     /* num parameters */ 7,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10270,7 +10312,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [155] */
+    /* [158] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10282,7 +10324,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [156] */
+    /* [159] */
     /* num parameters */ 6,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10294,7 +10336,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [157] */
+    /* [160] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10306,7 +10348,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [158] */
+    /* [161] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10318,7 +10360,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [159] */
+    /* [162] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10330,7 +10372,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [160] */
+    /* [163] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10342,7 +10384,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [161] */
+    /* [164] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10354,7 +10396,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [162] */
+    /* [165] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10366,7 +10408,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [163] */
+    /* [166] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10378,7 +10420,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [164] */
+    /* [167] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10390,7 +10432,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [165] */
+    /* [168] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10402,7 +10444,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [166] */
+    /* [169] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10414,7 +10456,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [167] */
+    /* [170] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10426,7 +10468,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [168] */
+    /* [171] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10438,7 +10480,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [169] */
+    /* [172] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10450,7 +10492,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [170] */
+    /* [173] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10462,7 +10504,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [171] */
+    /* [174] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10474,7 +10516,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [172] */
+    /* [175] */
     /* num parameters */ 5,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10486,7 +10528,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [173] */
+    /* [176] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10498,7 +10540,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [174] */
+    /* [177] */
     /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10510,7 +10552,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [175] */
+    /* [178] */
     /* num parameters */ 4,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -10522,7 +10564,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [176] */
+    /* [179] */
     /* num parameters */ 5,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -10534,583 +10576,511 @@
     /* const eval */ nullptr,
   },
   {
-    /* [177] */
+    /* [180] */
     /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[1014],
-    /* return matcher indices */ &kMatcherIndices[178],
+    /* return matcher indices */ &kMatcherIndices[184],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [178] */
-    /* num parameters */ 1,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[986],
-    /* return matcher indices */ &kMatcherIndices[178],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
-  },
-  {
-    /* [179] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[431],
-    /* return matcher indices */ &kMatcherIndices[178],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
-  },
-  {
-    /* [180] */
-    /* num parameters */ 2,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[794],
-    /* return matcher indices */ &kMatcherIndices[178],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
-  },
-  {
     /* [181] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[987],
-    /* return matcher indices */ &kMatcherIndices[182],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[986],
+    /* return matcher indices */ &kMatcherIndices[184],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [182] */
-    /* num parameters */ 1,
+    /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[988],
-    /* return matcher indices */ &kMatcherIndices[180],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[431],
+    /* return matcher indices */ &kMatcherIndices[184],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [183] */
-    /* num parameters */ 0,
+    /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[794],
     /* return matcher indices */ &kMatcherIndices[184],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [184] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[989],
-    /* return matcher indices */ &kMatcherIndices[184],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[987],
+    /* return matcher indices */ &kMatcherIndices[188],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [185] */
-    /* num parameters */ 6,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[138],
-    /* return matcher indices */ &kMatcherIndices[184],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[988],
+    /* return matcher indices */ &kMatcherIndices[186],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [186] */
-    /* num parameters */ 2,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[796],
-    /* return matcher indices */ &kMatcherIndices[184],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[190],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [187] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[990],
-    /* return matcher indices */ &kMatcherIndices[188],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[989],
+    /* return matcher indices */ &kMatcherIndices[190],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [188] */
-    /* num parameters */ 1,
+    /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[991],
-    /* return matcher indices */ &kMatcherIndices[186],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[138],
+    /* return matcher indices */ &kMatcherIndices[190],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [189] */
-    /* num parameters */ 0,
+    /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[796],
     /* return matcher indices */ &kMatcherIndices[190],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [190] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[992],
-    /* return matcher indices */ &kMatcherIndices[190],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[990],
+    /* return matcher indices */ &kMatcherIndices[194],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [191] */
-    /* num parameters */ 8,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[49],
-    /* return matcher indices */ &kMatcherIndices[190],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[991],
+    /* return matcher indices */ &kMatcherIndices[192],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [192] */
-    /* num parameters */ 2,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[798],
-    /* return matcher indices */ &kMatcherIndices[190],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[196],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [193] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[993],
-    /* return matcher indices */ &kMatcherIndices[194],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[992],
+    /* return matcher indices */ &kMatcherIndices[196],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [194] */
-    /* num parameters */ 1,
+    /* num parameters */ 8,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[994],
-    /* return matcher indices */ &kMatcherIndices[192],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[49],
+    /* return matcher indices */ &kMatcherIndices[196],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [195] */
-    /* num parameters */ 0,
+    /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[798],
     /* return matcher indices */ &kMatcherIndices[196],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [196] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[995],
-    /* return matcher indices */ &kMatcherIndices[196],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[993],
+    /* return matcher indices */ &kMatcherIndices[200],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [197] */
-    /* num parameters */ 6,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[144],
-    /* return matcher indices */ &kMatcherIndices[196],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[994],
+    /* return matcher indices */ &kMatcherIndices[198],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [198] */
-    /* num parameters */ 3,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[585],
-    /* return matcher indices */ &kMatcherIndices[196],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[202],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [199] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[996],
-    /* return matcher indices */ &kMatcherIndices[200],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[995],
+    /* return matcher indices */ &kMatcherIndices[202],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [200] */
-    /* num parameters */ 1,
+    /* num parameters */ 6,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[997],
-    /* return matcher indices */ &kMatcherIndices[198],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[144],
+    /* return matcher indices */ &kMatcherIndices[202],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [201] */
-    /* num parameters */ 0,
+    /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[585],
     /* return matcher indices */ &kMatcherIndices[202],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [202] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[998],
-    /* return matcher indices */ &kMatcherIndices[202],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[996],
+    /* return matcher indices */ &kMatcherIndices[206],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [203] */
-    /* num parameters */ 9,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[40],
-    /* return matcher indices */ &kMatcherIndices[202],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[997],
+    /* return matcher indices */ &kMatcherIndices[204],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [204] */
-    /* num parameters */ 3,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[588],
-    /* return matcher indices */ &kMatcherIndices[202],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[208],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [205] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[999],
-    /* return matcher indices */ &kMatcherIndices[206],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[998],
+    /* return matcher indices */ &kMatcherIndices[208],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [206] */
-    /* num parameters */ 1,
+    /* num parameters */ 9,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1000],
-    /* return matcher indices */ &kMatcherIndices[204],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[40],
+    /* return matcher indices */ &kMatcherIndices[208],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [207] */
-    /* num parameters */ 0,
+    /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[588],
     /* return matcher indices */ &kMatcherIndices[208],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [208] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1001],
-    /* return matcher indices */ &kMatcherIndices[208],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[999],
+    /* return matcher indices */ &kMatcherIndices[212],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [209] */
-    /* num parameters */ 12,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[16],
-    /* return matcher indices */ &kMatcherIndices[208],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[1000],
+    /* return matcher indices */ &kMatcherIndices[210],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [210] */
-    /* num parameters */ 3,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[591],
-    /* return matcher indices */ &kMatcherIndices[208],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[214],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [211] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1002],
-    /* return matcher indices */ &kMatcherIndices[212],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[1001],
+    /* return matcher indices */ &kMatcherIndices[214],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [212] */
-    /* num parameters */ 1,
+    /* num parameters */ 12,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1003],
-    /* return matcher indices */ &kMatcherIndices[210],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[16],
+    /* return matcher indices */ &kMatcherIndices[214],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [213] */
-    /* num parameters */ 0,
+    /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[591],
     /* return matcher indices */ &kMatcherIndices[214],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [214] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1004],
-    /* return matcher indices */ &kMatcherIndices[214],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
+    /* parameters */ &kParameters[1002],
+    /* return matcher indices */ &kMatcherIndices[218],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [215] */
-    /* num parameters */ 8,
+    /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[57],
-    /* return matcher indices */ &kMatcherIndices[214],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
+    /* parameters */ &kParameters[1003],
+    /* return matcher indices */ &kMatcherIndices[216],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
   },
   {
     /* [216] */
-    /* num parameters */ 4,
+    /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[435],
-    /* return matcher indices */ &kMatcherIndices[214],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[220],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
+    /* const eval */ &ConstEval::Zero,
   },
   {
     /* [217] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[16],
+    /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1005],
-    /* return matcher indices */ &kMatcherIndices[218],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[1004],
+    /* return matcher indices */ &kMatcherIndices[220],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
   },
   {
     /* [218] */
-    /* num parameters */ 1,
+    /* num parameters */ 8,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[14],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1006],
-    /* return matcher indices */ &kMatcherIndices[216],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Conv,
+    /* parameters */ &kParameters[57],
+    /* return matcher indices */ &kMatcherIndices[220],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
   },
   {
     /* [219] */
-    /* num parameters */ 0,
+    /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
+    /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1014],
+    /* parameters */ &kParameters[435],
     /* return matcher indices */ &kMatcherIndices[220],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Zero,
+    /* const eval */ &ConstEval::MatInitV,
   },
   {
     /* [220] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[37],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1007],
-    /* return matcher indices */ &kMatcherIndices[220],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::Identity,
-  },
-  {
-    /* [221] */
-    /* num parameters */ 12,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[28],
-    /* return matcher indices */ &kMatcherIndices[220],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitS,
-  },
-  {
-    /* [222] */
-    /* num parameters */ 4,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
-    /* template types */ &kTemplateTypes[10],
-    /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[439],
-    /* return matcher indices */ &kMatcherIndices[220],
-    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
-    /* const eval */ &ConstEval::MatInitV,
-  },
-  {
-    /* [223] */
-    /* num parameters */ 1,
-    /* num template types */ 1,
-    /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1008],
+    /* parameters */ &kParameters[1005],
     /* return matcher indices */ &kMatcherIndices[224],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [224] */
+    /* [221] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1009],
+    /* parameters */ &kParameters[1006],
     /* return matcher indices */ &kMatcherIndices[222],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [225] */
+    /* [222] */
     /* num parameters */ 0,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11122,67 +11092,139 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [226] */
+    /* [223] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[37],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[1010],
+    /* parameters */ &kParameters[1007],
     /* return matcher indices */ &kMatcherIndices[226],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [227] */
-    /* num parameters */ 16,
+    /* [224] */
+    /* num parameters */ 12,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[0],
+    /* parameters */ &kParameters[28],
     /* return matcher indices */ &kMatcherIndices[226],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::MatInitS,
   },
   {
-    /* [228] */
+    /* [225] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[10],
     /* template numbers */ &kTemplateNumbers[10],
-    /* parameters */ &kParameters[443],
+    /* parameters */ &kParameters[439],
     /* return matcher indices */ &kMatcherIndices[226],
     /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::MatInitV,
   },
   {
+    /* [226] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[16],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[1008],
+    /* return matcher indices */ &kMatcherIndices[230],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
+  },
+  {
+    /* [227] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[14],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[1009],
+    /* return matcher indices */ &kMatcherIndices[228],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Conv,
+  },
+  {
+    /* [228] */
+    /* num parameters */ 0,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[37],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[1014],
+    /* return matcher indices */ &kMatcherIndices[232],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Zero,
+  },
+  {
     /* [229] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[37],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[1010],
+    /* return matcher indices */ &kMatcherIndices[232],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::Identity,
+  },
+  {
+    /* [230] */
+    /* num parameters */ 16,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[0],
+    /* return matcher indices */ &kMatcherIndices[232],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitS,
+  },
+  {
+    /* [231] */
+    /* num parameters */ 4,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
+    /* template types */ &kTemplateTypes[10],
+    /* template numbers */ &kTemplateNumbers[10],
+    /* parameters */ &kParameters[443],
+    /* return matcher indices */ &kMatcherIndices[232],
+    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
+    /* const eval */ &ConstEval::MatInitV,
+  },
+  {
+    /* [232] */
+    /* num parameters */ 1,
+    /* num template types */ 1,
+    /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[16],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[1011],
-    /* return matcher indices */ &kMatcherIndices[230],
+    /* return matcher indices */ &kMatcherIndices[236],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [230] */
+    /* [233] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[14],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[1012],
-    /* return matcher indices */ &kMatcherIndices[228],
+    /* return matcher indices */ &kMatcherIndices[234],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [231] */
+    /* [234] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11194,7 +11236,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [232] */
+    /* [235] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11206,7 +11248,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [233] */
+    /* [236] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11218,7 +11260,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [234] */
+    /* [237] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11230,7 +11272,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [235] */
+    /* [238] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 2,
@@ -11242,7 +11284,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [236] */
+    /* [239] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11254,7 +11296,7 @@
     /* const eval */ &ConstEval::OpPlus,
   },
   {
-    /* [237] */
+    /* [240] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11266,7 +11308,7 @@
     /* const eval */ &ConstEval::OpPlus,
   },
   {
-    /* [238] */
+    /* [241] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11278,7 +11320,7 @@
     /* const eval */ &ConstEval::OpPlus,
   },
   {
-    /* [239] */
+    /* [242] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11290,7 +11332,7 @@
     /* const eval */ &ConstEval::OpPlus,
   },
   {
-    /* [240] */
+    /* [243] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 2,
@@ -11302,7 +11344,7 @@
     /* const eval */ &ConstEval::OpPlus,
   },
   {
-    /* [241] */
+    /* [244] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11314,7 +11356,7 @@
     /* const eval */ &ConstEval::OpMinus,
   },
   {
-    /* [242] */
+    /* [245] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11326,7 +11368,7 @@
     /* const eval */ &ConstEval::OpMinus,
   },
   {
-    /* [243] */
+    /* [246] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11338,7 +11380,7 @@
     /* const eval */ &ConstEval::OpMinus,
   },
   {
-    /* [244] */
+    /* [247] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11350,7 +11392,7 @@
     /* const eval */ &ConstEval::OpMinus,
   },
   {
-    /* [245] */
+    /* [248] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 2,
@@ -11362,7 +11404,7 @@
     /* const eval */ &ConstEval::OpMinus,
   },
   {
-    /* [246] */
+    /* [249] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11374,7 +11416,7 @@
     /* const eval */ &ConstEval::OpDivide,
   },
   {
-    /* [247] */
+    /* [250] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11386,7 +11428,7 @@
     /* const eval */ &ConstEval::OpDivide,
   },
   {
-    /* [248] */
+    /* [251] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11398,7 +11440,7 @@
     /* const eval */ &ConstEval::OpDivide,
   },
   {
-    /* [249] */
+    /* [252] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11410,7 +11452,7 @@
     /* const eval */ &ConstEval::OpDivide,
   },
   {
-    /* [250] */
+    /* [253] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11422,7 +11464,7 @@
     /* const eval */ &ConstEval::OpModulo,
   },
   {
-    /* [251] */
+    /* [254] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11434,7 +11476,7 @@
     /* const eval */ &ConstEval::OpModulo,
   },
   {
-    /* [252] */
+    /* [255] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11446,7 +11488,7 @@
     /* const eval */ &ConstEval::OpModulo,
   },
   {
-    /* [253] */
+    /* [256] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11458,7 +11500,7 @@
     /* const eval */ &ConstEval::OpModulo,
   },
   {
-    /* [254] */
+    /* [257] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11470,7 +11512,7 @@
     /* const eval */ &ConstEval::OpAnd,
   },
   {
-    /* [255] */
+    /* [258] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11482,7 +11524,7 @@
     /* const eval */ &ConstEval::OpAnd,
   },
   {
-    /* [256] */
+    /* [259] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11494,7 +11536,7 @@
     /* const eval */ &ConstEval::OpAnd,
   },
   {
-    /* [257] */
+    /* [260] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11506,7 +11548,7 @@
     /* const eval */ &ConstEval::OpAnd,
   },
   {
-    /* [258] */
+    /* [261] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11518,7 +11560,7 @@
     /* const eval */ &ConstEval::OpOr,
   },
   {
-    /* [259] */
+    /* [262] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11530,7 +11572,7 @@
     /* const eval */ &ConstEval::OpOr,
   },
   {
-    /* [260] */
+    /* [263] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11542,7 +11584,7 @@
     /* const eval */ &ConstEval::OpOr,
   },
   {
-    /* [261] */
+    /* [264] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11554,7 +11596,7 @@
     /* const eval */ &ConstEval::OpOr,
   },
   {
-    /* [262] */
+    /* [265] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11566,7 +11608,7 @@
     /* const eval */ &ConstEval::mix,
   },
   {
-    /* [263] */
+    /* [266] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11578,7 +11620,7 @@
     /* const eval */ &ConstEval::mix,
   },
   {
-    /* [264] */
+    /* [267] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11590,7 +11632,7 @@
     /* const eval */ &ConstEval::mix,
   },
   {
-    /* [265] */
+    /* [268] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11602,7 +11644,7 @@
     /* const eval */ &ConstEval::select_bool,
   },
   {
-    /* [266] */
+    /* [269] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11614,7 +11656,7 @@
     /* const eval */ &ConstEval::select_bool,
   },
   {
-    /* [267] */
+    /* [270] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11626,7 +11668,7 @@
     /* const eval */ &ConstEval::select_boolvec,
   },
   {
-    /* [268] */
+    /* [271] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11638,7 +11680,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [269] */
+    /* [272] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11650,7 +11692,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [270] */
+    /* [273] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11662,7 +11704,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [271] */
+    /* [274] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11674,7 +11716,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [272] */
+    /* [275] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11686,7 +11728,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [273] */
+    /* [276] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11698,7 +11740,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [274] */
+    /* [277] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11710,7 +11752,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [275] */
+    /* [278] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11722,7 +11764,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [276] */
+    /* [279] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11734,7 +11776,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [277] */
+    /* [280] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11746,7 +11788,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [278] */
+    /* [281] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11758,7 +11800,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [279] */
+    /* [282] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11770,7 +11812,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [280] */
+    /* [283] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11782,7 +11824,7 @@
     /* const eval */ &ConstEval::Zero,
   },
   {
-    /* [281] */
+    /* [284] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11794,7 +11836,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [282] */
+    /* [285] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11806,7 +11848,7 @@
     /* const eval */ &ConstEval::Conv,
   },
   {
-    /* [283] */
+    /* [286] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11818,7 +11860,7 @@
     /* const eval */ &ConstEval::abs,
   },
   {
-    /* [284] */
+    /* [287] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11830,7 +11872,7 @@
     /* const eval */ &ConstEval::abs,
   },
   {
-    /* [285] */
+    /* [288] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11842,7 +11884,7 @@
     /* const eval */ &ConstEval::acos,
   },
   {
-    /* [286] */
+    /* [289] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11854,7 +11896,7 @@
     /* const eval */ &ConstEval::acos,
   },
   {
-    /* [287] */
+    /* [290] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11866,7 +11908,7 @@
     /* const eval */ &ConstEval::acosh,
   },
   {
-    /* [288] */
+    /* [291] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11878,7 +11920,7 @@
     /* const eval */ &ConstEval::acosh,
   },
   {
-    /* [289] */
+    /* [292] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11890,7 +11932,7 @@
     /* const eval */ &ConstEval::all,
   },
   {
-    /* [290] */
+    /* [293] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11902,7 +11944,7 @@
     /* const eval */ &ConstEval::all,
   },
   {
-    /* [291] */
+    /* [294] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -11914,7 +11956,7 @@
     /* const eval */ &ConstEval::any,
   },
   {
-    /* [292] */
+    /* [295] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -11926,7 +11968,7 @@
     /* const eval */ &ConstEval::any,
   },
   {
-    /* [293] */
+    /* [296] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11938,7 +11980,7 @@
     /* const eval */ &ConstEval::asin,
   },
   {
-    /* [294] */
+    /* [297] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11950,7 +11992,7 @@
     /* const eval */ &ConstEval::asin,
   },
   {
-    /* [295] */
+    /* [298] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11962,7 +12004,7 @@
     /* const eval */ &ConstEval::asinh,
   },
   {
-    /* [296] */
+    /* [299] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11974,7 +12016,7 @@
     /* const eval */ &ConstEval::asinh,
   },
   {
-    /* [297] */
+    /* [300] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -11986,7 +12028,7 @@
     /* const eval */ &ConstEval::atan,
   },
   {
-    /* [298] */
+    /* [301] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -11998,7 +12040,7 @@
     /* const eval */ &ConstEval::atan,
   },
   {
-    /* [299] */
+    /* [302] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12010,7 +12052,7 @@
     /* const eval */ &ConstEval::atan2,
   },
   {
-    /* [300] */
+    /* [303] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12022,7 +12064,7 @@
     /* const eval */ &ConstEval::atan2,
   },
   {
-    /* [301] */
+    /* [304] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12034,7 +12076,7 @@
     /* const eval */ &ConstEval::atanh,
   },
   {
-    /* [302] */
+    /* [305] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12046,7 +12088,7 @@
     /* const eval */ &ConstEval::atanh,
   },
   {
-    /* [303] */
+    /* [306] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12058,7 +12100,7 @@
     /* const eval */ &ConstEval::ceil,
   },
   {
-    /* [304] */
+    /* [307] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12070,7 +12112,7 @@
     /* const eval */ &ConstEval::ceil,
   },
   {
-    /* [305] */
+    /* [308] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12082,7 +12124,7 @@
     /* const eval */ &ConstEval::clamp,
   },
   {
-    /* [306] */
+    /* [309] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12094,7 +12136,7 @@
     /* const eval */ &ConstEval::clamp,
   },
   {
-    /* [307] */
+    /* [310] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12106,7 +12148,7 @@
     /* const eval */ &ConstEval::cos,
   },
   {
-    /* [308] */
+    /* [311] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12118,7 +12160,7 @@
     /* const eval */ &ConstEval::cos,
   },
   {
-    /* [309] */
+    /* [312] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12130,7 +12172,7 @@
     /* const eval */ &ConstEval::cosh,
   },
   {
-    /* [310] */
+    /* [313] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12142,7 +12184,7 @@
     /* const eval */ &ConstEval::cosh,
   },
   {
-    /* [311] */
+    /* [314] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12154,7 +12196,7 @@
     /* const eval */ &ConstEval::countLeadingZeros,
   },
   {
-    /* [312] */
+    /* [315] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12166,7 +12208,7 @@
     /* const eval */ &ConstEval::countLeadingZeros,
   },
   {
-    /* [313] */
+    /* [316] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12178,7 +12220,7 @@
     /* const eval */ &ConstEval::countOneBits,
   },
   {
-    /* [314] */
+    /* [317] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12190,7 +12232,7 @@
     /* const eval */ &ConstEval::countOneBits,
   },
   {
-    /* [315] */
+    /* [318] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12202,7 +12244,7 @@
     /* const eval */ &ConstEval::countTrailingZeros,
   },
   {
-    /* [316] */
+    /* [319] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12214,7 +12256,7 @@
     /* const eval */ &ConstEval::countTrailingZeros,
   },
   {
-    /* [317] */
+    /* [320] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12226,7 +12268,7 @@
     /* const eval */ &ConstEval::degrees,
   },
   {
-    /* [318] */
+    /* [321] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12238,7 +12280,7 @@
     /* const eval */ &ConstEval::degrees,
   },
   {
-    /* [319] */
+    /* [322] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12250,7 +12292,7 @@
     /* const eval */ &ConstEval::distance,
   },
   {
-    /* [320] */
+    /* [323] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12262,7 +12304,7 @@
     /* const eval */ &ConstEval::distance,
   },
   {
-    /* [321] */
+    /* [324] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12274,7 +12316,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [322] */
+    /* [325] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12286,7 +12328,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [323] */
+    /* [326] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12298,7 +12340,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [324] */
+    /* [327] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12310,7 +12352,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [325] */
+    /* [328] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12322,7 +12364,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [326] */
+    /* [329] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12334,7 +12376,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [327] */
+    /* [330] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12346,7 +12388,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [328] */
+    /* [331] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12358,7 +12400,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [329] */
+    /* [332] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12370,7 +12412,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [330] */
+    /* [333] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12382,7 +12424,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [331] */
+    /* [334] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12394,7 +12436,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [332] */
+    /* [335] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12406,7 +12448,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [333] */
+    /* [336] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12418,7 +12460,7 @@
     /* const eval */ &ConstEval::exp,
   },
   {
-    /* [334] */
+    /* [337] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12430,7 +12472,7 @@
     /* const eval */ &ConstEval::exp,
   },
   {
-    /* [335] */
+    /* [338] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12442,7 +12484,7 @@
     /* const eval */ &ConstEval::exp2,
   },
   {
-    /* [336] */
+    /* [339] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12454,7 +12496,7 @@
     /* const eval */ &ConstEval::exp2,
   },
   {
-    /* [337] */
+    /* [340] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12466,7 +12508,7 @@
     /* const eval */ &ConstEval::extractBits,
   },
   {
-    /* [338] */
+    /* [341] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12478,7 +12520,7 @@
     /* const eval */ &ConstEval::extractBits,
   },
   {
-    /* [339] */
+    /* [342] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12490,7 +12532,7 @@
     /* const eval */ &ConstEval::firstLeadingBit,
   },
   {
-    /* [340] */
+    /* [343] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12502,7 +12544,7 @@
     /* const eval */ &ConstEval::firstLeadingBit,
   },
   {
-    /* [341] */
+    /* [344] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12514,7 +12556,7 @@
     /* const eval */ &ConstEval::firstTrailingBit,
   },
   {
-    /* [342] */
+    /* [345] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12526,7 +12568,7 @@
     /* const eval */ &ConstEval::firstTrailingBit,
   },
   {
-    /* [343] */
+    /* [346] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12538,7 +12580,7 @@
     /* const eval */ &ConstEval::floor,
   },
   {
-    /* [344] */
+    /* [347] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12550,7 +12592,7 @@
     /* const eval */ &ConstEval::floor,
   },
   {
-    /* [345] */
+    /* [348] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12562,7 +12604,7 @@
     /* const eval */ &ConstEval::fma,
   },
   {
-    /* [346] */
+    /* [349] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12574,7 +12616,7 @@
     /* const eval */ &ConstEval::fma,
   },
   {
-    /* [347] */
+    /* [350] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12586,7 +12628,7 @@
     /* const eval */ &ConstEval::fract,
   },
   {
-    /* [348] */
+    /* [351] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12598,7 +12640,7 @@
     /* const eval */ &ConstEval::fract,
   },
   {
-    /* [349] */
+    /* [352] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12610,7 +12652,7 @@
     /* const eval */ &ConstEval::frexp,
   },
   {
-    /* [350] */
+    /* [353] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12622,7 +12664,7 @@
     /* const eval */ &ConstEval::frexp,
   },
   {
-    /* [351] */
+    /* [354] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12634,7 +12676,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [352] */
+    /* [355] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12646,7 +12688,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [353] */
+    /* [356] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12658,7 +12700,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [354] */
+    /* [357] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12670,7 +12712,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [355] */
+    /* [358] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12682,7 +12724,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [356] */
+    /* [359] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12694,7 +12736,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [357] */
+    /* [360] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12706,7 +12748,7 @@
     /* const eval */ &ConstEval::insertBits,
   },
   {
-    /* [358] */
+    /* [361] */
     /* num parameters */ 4,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12718,7 +12760,7 @@
     /* const eval */ &ConstEval::insertBits,
   },
   {
-    /* [359] */
+    /* [362] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12730,7 +12772,7 @@
     /* const eval */ &ConstEval::inverseSqrt,
   },
   {
-    /* [360] */
+    /* [363] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12742,7 +12784,7 @@
     /* const eval */ &ConstEval::inverseSqrt,
   },
   {
-    /* [361] */
+    /* [364] */
     /* num parameters */ 2,
     /* num template types */ 2,
     /* num template numbers */ 0,
@@ -12754,7 +12796,7 @@
     /* const eval */ &ConstEval::ldexp,
   },
   {
-    /* [362] */
+    /* [365] */
     /* num parameters */ 2,
     /* num template types */ 2,
     /* num template numbers */ 1,
@@ -12766,7 +12808,7 @@
     /* const eval */ &ConstEval::ldexp,
   },
   {
-    /* [363] */
+    /* [366] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12778,7 +12820,7 @@
     /* const eval */ &ConstEval::length,
   },
   {
-    /* [364] */
+    /* [367] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12790,7 +12832,7 @@
     /* const eval */ &ConstEval::length,
   },
   {
-    /* [365] */
+    /* [368] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12802,7 +12844,7 @@
     /* const eval */ &ConstEval::log,
   },
   {
-    /* [366] */
+    /* [369] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12814,7 +12856,7 @@
     /* const eval */ &ConstEval::log,
   },
   {
-    /* [367] */
+    /* [370] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12826,7 +12868,7 @@
     /* const eval */ &ConstEval::log2,
   },
   {
-    /* [368] */
+    /* [371] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12838,7 +12880,7 @@
     /* const eval */ &ConstEval::log2,
   },
   {
-    /* [369] */
+    /* [372] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12850,7 +12892,7 @@
     /* const eval */ &ConstEval::max,
   },
   {
-    /* [370] */
+    /* [373] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12862,7 +12904,7 @@
     /* const eval */ &ConstEval::max,
   },
   {
-    /* [371] */
+    /* [374] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12874,7 +12916,7 @@
     /* const eval */ &ConstEval::min,
   },
   {
-    /* [372] */
+    /* [375] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12886,7 +12928,7 @@
     /* const eval */ &ConstEval::min,
   },
   {
-    /* [373] */
+    /* [376] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12898,7 +12940,7 @@
     /* const eval */ &ConstEval::modf,
   },
   {
-    /* [374] */
+    /* [377] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12910,7 +12952,7 @@
     /* const eval */ &ConstEval::modf,
   },
   {
-    /* [375] */
+    /* [378] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12922,7 +12964,7 @@
     /* const eval */ &ConstEval::pow,
   },
   {
-    /* [376] */
+    /* [379] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12934,7 +12976,7 @@
     /* const eval */ &ConstEval::pow,
   },
   {
-    /* [377] */
+    /* [380] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -12946,7 +12988,7 @@
     /* const eval */ &ConstEval::quantizeToF16,
   },
   {
-    /* [378] */
+    /* [381] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -12958,7 +13000,7 @@
     /* const eval */ &ConstEval::quantizeToF16,
   },
   {
-    /* [379] */
+    /* [382] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12970,7 +13012,7 @@
     /* const eval */ &ConstEval::radians,
   },
   {
-    /* [380] */
+    /* [383] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -12982,7 +13024,7 @@
     /* const eval */ &ConstEval::radians,
   },
   {
-    /* [381] */
+    /* [384] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -12994,7 +13036,7 @@
     /* const eval */ &ConstEval::reverseBits,
   },
   {
-    /* [382] */
+    /* [385] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13006,7 +13048,7 @@
     /* const eval */ &ConstEval::reverseBits,
   },
   {
-    /* [383] */
+    /* [386] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13018,7 +13060,7 @@
     /* const eval */ &ConstEval::round,
   },
   {
-    /* [384] */
+    /* [387] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13030,7 +13072,7 @@
     /* const eval */ &ConstEval::round,
   },
   {
-    /* [385] */
+    /* [388] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13042,7 +13084,7 @@
     /* const eval */ &ConstEval::saturate,
   },
   {
-    /* [386] */
+    /* [389] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13054,7 +13096,7 @@
     /* const eval */ &ConstEval::saturate,
   },
   {
-    /* [387] */
+    /* [390] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13066,7 +13108,7 @@
     /* const eval */ &ConstEval::sign,
   },
   {
-    /* [388] */
+    /* [391] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13078,7 +13120,7 @@
     /* const eval */ &ConstEval::sign,
   },
   {
-    /* [389] */
+    /* [392] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13090,7 +13132,7 @@
     /* const eval */ &ConstEval::sin,
   },
   {
-    /* [390] */
+    /* [393] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13102,7 +13144,7 @@
     /* const eval */ &ConstEval::sin,
   },
   {
-    /* [391] */
+    /* [394] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13114,7 +13156,7 @@
     /* const eval */ &ConstEval::sinh,
   },
   {
-    /* [392] */
+    /* [395] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13126,7 +13168,7 @@
     /* const eval */ &ConstEval::sinh,
   },
   {
-    /* [393] */
+    /* [396] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13138,7 +13180,7 @@
     /* const eval */ &ConstEval::smoothstep,
   },
   {
-    /* [394] */
+    /* [397] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13150,7 +13192,7 @@
     /* const eval */ &ConstEval::smoothstep,
   },
   {
-    /* [395] */
+    /* [398] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13162,7 +13204,7 @@
     /* const eval */ &ConstEval::sqrt,
   },
   {
-    /* [396] */
+    /* [399] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13174,7 +13216,7 @@
     /* const eval */ &ConstEval::sqrt,
   },
   {
-    /* [397] */
+    /* [400] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13186,7 +13228,7 @@
     /* const eval */ &ConstEval::step,
   },
   {
-    /* [398] */
+    /* [401] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13198,7 +13240,7 @@
     /* const eval */ &ConstEval::step,
   },
   {
-    /* [399] */
+    /* [402] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13210,7 +13252,7 @@
     /* const eval */ &ConstEval::tan,
   },
   {
-    /* [400] */
+    /* [403] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13222,7 +13264,7 @@
     /* const eval */ &ConstEval::tan,
   },
   {
-    /* [401] */
+    /* [404] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13234,7 +13276,7 @@
     /* const eval */ &ConstEval::tanh,
   },
   {
-    /* [402] */
+    /* [405] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13246,7 +13288,7 @@
     /* const eval */ &ConstEval::tanh,
   },
   {
-    /* [403] */
+    /* [406] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13258,7 +13300,7 @@
     /* const eval */ &ConstEval::trunc,
   },
   {
-    /* [404] */
+    /* [407] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13270,7 +13312,7 @@
     /* const eval */ &ConstEval::trunc,
   },
   {
-    /* [405] */
+    /* [408] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13282,7 +13324,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [406] */
+    /* [409] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13294,7 +13336,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [407] */
+    /* [410] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13306,7 +13348,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [408] */
+    /* [411] */
     /* num parameters */ 3,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13318,7 +13360,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [409] */
+    /* [412] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13330,7 +13372,7 @@
     /* const eval */ &ConstEval::OpNot,
   },
   {
-    /* [410] */
+    /* [413] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 1,
@@ -13342,7 +13384,7 @@
     /* const eval */ &ConstEval::OpNot,
   },
   {
-    /* [411] */
+    /* [414] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13354,7 +13396,7 @@
     /* const eval */ &ConstEval::OpComplement,
   },
   {
-    /* [412] */
+    /* [415] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13366,7 +13408,7 @@
     /* const eval */ &ConstEval::OpComplement,
   },
   {
-    /* [413] */
+    /* [416] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13378,7 +13420,7 @@
     /* const eval */ &ConstEval::OpUnaryMinus,
   },
   {
-    /* [414] */
+    /* [417] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13390,7 +13432,7 @@
     /* const eval */ &ConstEval::OpUnaryMinus,
   },
   {
-    /* [415] */
+    /* [418] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13402,7 +13444,7 @@
     /* const eval */ &ConstEval::OpXor,
   },
   {
-    /* [416] */
+    /* [419] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13414,7 +13456,7 @@
     /* const eval */ &ConstEval::OpXor,
   },
   {
-    /* [417] */
+    /* [420] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13426,7 +13468,7 @@
     /* const eval */ &ConstEval::OpEqual,
   },
   {
-    /* [418] */
+    /* [421] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13438,7 +13480,7 @@
     /* const eval */ &ConstEval::OpEqual,
   },
   {
-    /* [419] */
+    /* [422] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13450,7 +13492,7 @@
     /* const eval */ &ConstEval::OpNotEqual,
   },
   {
-    /* [420] */
+    /* [423] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13462,7 +13504,7 @@
     /* const eval */ &ConstEval::OpNotEqual,
   },
   {
-    /* [421] */
+    /* [424] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13474,7 +13516,7 @@
     /* const eval */ &ConstEval::OpLessThan,
   },
   {
-    /* [422] */
+    /* [425] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13486,7 +13528,7 @@
     /* const eval */ &ConstEval::OpLessThan,
   },
   {
-    /* [423] */
+    /* [426] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13498,7 +13540,7 @@
     /* const eval */ &ConstEval::OpGreaterThan,
   },
   {
-    /* [424] */
+    /* [427] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13510,7 +13552,7 @@
     /* const eval */ &ConstEval::OpGreaterThan,
   },
   {
-    /* [425] */
+    /* [428] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13522,7 +13564,7 @@
     /* const eval */ &ConstEval::OpLessThanEqual,
   },
   {
-    /* [426] */
+    /* [429] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13534,7 +13576,7 @@
     /* const eval */ &ConstEval::OpLessThanEqual,
   },
   {
-    /* [427] */
+    /* [430] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13546,7 +13588,7 @@
     /* const eval */ &ConstEval::OpGreaterThanEqual,
   },
   {
-    /* [428] */
+    /* [431] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13558,7 +13600,7 @@
     /* const eval */ &ConstEval::OpGreaterThanEqual,
   },
   {
-    /* [429] */
+    /* [432] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13570,7 +13612,7 @@
     /* const eval */ &ConstEval::OpShiftLeft,
   },
   {
-    /* [430] */
+    /* [433] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13582,7 +13624,7 @@
     /* const eval */ &ConstEval::OpShiftLeft,
   },
   {
-    /* [431] */
+    /* [434] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13594,7 +13636,7 @@
     /* const eval */ &ConstEval::OpShiftRight,
   },
   {
-    /* [432] */
+    /* [435] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13606,7 +13648,7 @@
     /* const eval */ &ConstEval::OpShiftRight,
   },
   {
-    /* [433] */
+    /* [436] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13618,7 +13660,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [434] */
+    /* [437] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13630,7 +13672,7 @@
     /* const eval */ &ConstEval::cross,
   },
   {
-    /* [435] */
+    /* [438] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13642,7 +13684,7 @@
     /* const eval */ &ConstEval::determinant,
   },
   {
-    /* [436] */
+    /* [439] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13654,7 +13696,7 @@
     /* const eval */ &ConstEval::dot,
   },
   {
-    /* [437] */
+    /* [440] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13666,7 +13708,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [438] */
+    /* [441] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13678,7 +13720,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [439] */
+    /* [442] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13690,7 +13732,7 @@
     /* const eval */ &ConstEval::faceForward,
   },
   {
-    /* [440] */
+    /* [443] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13702,7 +13744,7 @@
     /* const eval */ &ConstEval::normalize,
   },
   {
-    /* [441] */
+    /* [444] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13714,7 +13756,7 @@
     /* const eval */ &ConstEval::pack2x16float,
   },
   {
-    /* [442] */
+    /* [445] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13726,7 +13768,7 @@
     /* const eval */ &ConstEval::pack2x16snorm,
   },
   {
-    /* [443] */
+    /* [446] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13738,7 +13780,7 @@
     /* const eval */ &ConstEval::pack2x16unorm,
   },
   {
-    /* [444] */
+    /* [447] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13750,7 +13792,7 @@
     /* const eval */ &ConstEval::pack4x8snorm,
   },
   {
-    /* [445] */
+    /* [448] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13762,7 +13804,7 @@
     /* const eval */ &ConstEval::pack4x8unorm,
   },
   {
-    /* [446] */
+    /* [449] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13774,7 +13816,7 @@
     /* const eval */ &ConstEval::reflect,
   },
   {
-    /* [447] */
+    /* [450] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13786,7 +13828,7 @@
     /* const eval */ &ConstEval::refract,
   },
   {
-    /* [448] */
+    /* [451] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13798,7 +13840,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [449] */
+    /* [452] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 2,
@@ -13810,7 +13852,7 @@
     /* const eval */ &ConstEval::transpose,
   },
   {
-    /* [450] */
+    /* [453] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13822,7 +13864,7 @@
     /* const eval */ &ConstEval::unpack2x16float,
   },
   {
-    /* [451] */
+    /* [454] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13834,7 +13876,7 @@
     /* const eval */ &ConstEval::unpack2x16snorm,
   },
   {
-    /* [452] */
+    /* [455] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13846,7 +13888,7 @@
     /* const eval */ &ConstEval::unpack2x16unorm,
   },
   {
-    /* [453] */
+    /* [456] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13858,7 +13900,7 @@
     /* const eval */ &ConstEval::unpack4x8snorm,
   },
   {
-    /* [454] */
+    /* [457] */
     /* num parameters */ 1,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13870,7 +13912,7 @@
     /* const eval */ &ConstEval::unpack4x8unorm,
   },
   {
-    /* [455] */
+    /* [458] */
     /* num parameters */ 0,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -13882,7 +13924,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [456] */
+    /* [459] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -13894,7 +13936,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [457] */
+    /* [460] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13906,7 +13948,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [458] */
+    /* [461] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13918,7 +13960,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [459] */
+    /* [462] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13930,7 +13972,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [460] */
+    /* [463] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13942,7 +13984,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [461] */
+    /* [464] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13954,7 +13996,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [462] */
+    /* [465] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13966,7 +14008,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [463] */
+    /* [466] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13978,7 +14020,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [464] */
+    /* [467] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -13990,7 +14032,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [465] */
+    /* [468] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -14002,7 +14044,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [466] */
+    /* [469] */
     /* num parameters */ 2,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -14014,7 +14056,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [467] */
+    /* [470] */
     /* num parameters */ 3,
     /* num template types */ 1,
     /* num template numbers */ 1,
@@ -14026,7 +14068,7 @@
     /* const eval */ nullptr,
   },
   {
-    /* [468] */
+    /* [471] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
@@ -14038,7 +14080,7 @@
     /* const eval */ &ConstEval::Identity,
   },
   {
-    /* [469] */
+    /* [472] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -14050,7 +14092,7 @@
     /* const eval */ &ConstEval::OpLogicalAnd,
   },
   {
-    /* [470] */
+    /* [473] */
     /* num parameters */ 2,
     /* num template types */ 0,
     /* num template numbers */ 0,
@@ -14062,14 +14104,14 @@
     /* const eval */ &ConstEval::OpLogicalOr,
   },
   {
-    /* [471] */
+    /* [474] */
     /* num parameters */ 1,
     /* num template types */ 1,
     /* num template numbers */ 0,
     /* template types */ &kTemplateTypes[36],
     /* template numbers */ &kTemplateNumbers[10],
     /* parameters */ &kParameters[1013],
-    /* return matcher indices */ &kMatcherIndices[232],
+    /* return matcher indices */ &kMatcherIndices[238],
     /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
     /* const eval */ &ConstEval::Conv,
   },
@@ -14081,357 +14123,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[283],
+    /* overloads */ &kOverloads[286],
   },
   {
     /* [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[285],
+    /* overloads */ &kOverloads[288],
   },
   {
     /* [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[287],
+    /* overloads */ &kOverloads[290],
   },
   {
     /* [3] */
     /* fn all(bool) -> bool */
     /* fn all<N : num>(vec<N, bool>) -> bool */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[289],
+    /* overloads */ &kOverloads[292],
   },
   {
     /* [4] */
     /* fn any(bool) -> bool */
     /* fn any<N : num>(vec<N, bool>) -> bool */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[291],
+    /* overloads */ &kOverloads[294],
   },
   {
     /* [5] */
     /* fn arrayLength<T, A : access>(ptr<storage, array<T>, A>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[433],
+    /* overloads */ &kOverloads[436],
   },
   {
     /* [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[293],
+    /* overloads */ &kOverloads[296],
   },
   {
     /* [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[295],
+    /* overloads */ &kOverloads[298],
   },
   {
     /* [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[297],
+    /* overloads */ &kOverloads[300],
   },
   {
     /* [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[299],
+    /* overloads */ &kOverloads[302],
   },
   {
     /* [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[301],
+    /* overloads */ &kOverloads[304],
   },
   {
     /* [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[303],
+    /* overloads */ &kOverloads[306],
   },
   {
     /* [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[305],
+    /* overloads */ &kOverloads[308],
   },
   {
     /* [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[307],
+    /* overloads */ &kOverloads[310],
   },
   {
     /* [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[309],
+    /* overloads */ &kOverloads[312],
   },
   {
     /* [15] */
     /* fn countLeadingZeros<T : iu32>(T) -> T */
     /* fn countLeadingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[311],
+    /* overloads */ &kOverloads[314],
   },
   {
     /* [16] */
     /* fn countOneBits<T : iu32>(T) -> T */
     /* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[313],
+    /* overloads */ &kOverloads[316],
   },
   {
     /* [17] */
     /* fn countTrailingZeros<T : iu32>(T) -> T */
     /* fn countTrailingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[315],
+    /* overloads */ &kOverloads[318],
   },
   {
     /* [18] */
     /* fn cross<T : fa_f32_f16>(vec3<T>, vec3<T>) -> vec3<T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[434],
+    /* overloads */ &kOverloads[437],
   },
   {
     /* [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[317],
+    /* overloads */ &kOverloads[320],
   },
   {
     /* [20] */
     /* fn determinant<N : num, T : fa_f32_f16>(mat<N, N, T>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[435],
+    /* overloads */ &kOverloads[438],
   },
   {
     /* [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[319],
+    /* overloads */ &kOverloads[322],
   },
   {
     /* [22] */
     /* fn dot<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[436],
+    /* overloads */ &kOverloads[439],
   },
   {
     /* [23] */
     /* fn dot4I8Packed(u32, u32) -> i32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[437],
+    /* overloads */ &kOverloads[440],
   },
   {
     /* [24] */
     /* fn dot4U8Packed(u32, u32) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[438],
+    /* overloads */ &kOverloads[441],
   },
   {
     /* [25] */
     /* fn dpdx(f32) -> f32 */
     /* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[321],
+    /* overloads */ &kOverloads[324],
   },
   {
     /* [26] */
     /* fn dpdxCoarse(f32) -> f32 */
     /* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[323],
+    /* overloads */ &kOverloads[326],
   },
   {
     /* [27] */
     /* fn dpdxFine(f32) -> f32 */
     /* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[325],
+    /* overloads */ &kOverloads[328],
   },
   {
     /* [28] */
     /* fn dpdy(f32) -> f32 */
     /* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[327],
+    /* overloads */ &kOverloads[330],
   },
   {
     /* [29] */
     /* fn dpdyCoarse(f32) -> f32 */
     /* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[329],
+    /* overloads */ &kOverloads[332],
   },
   {
     /* [30] */
     /* fn dpdyFine(f32) -> f32 */
     /* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[331],
+    /* overloads */ &kOverloads[334],
   },
   {
     /* [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[333],
+    /* overloads */ &kOverloads[336],
   },
   {
     /* [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[335],
+    /* overloads */ &kOverloads[338],
   },
   {
     /* [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[337],
+    /* overloads */ &kOverloads[340],
   },
   {
     /* [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[439],
+    /* overloads */ &kOverloads[442],
   },
   {
     /* [35] */
     /* fn firstLeadingBit<T : iu32>(T) -> T */
     /* fn firstLeadingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[339],
+    /* overloads */ &kOverloads[342],
   },
   {
     /* [36] */
     /* fn firstTrailingBit<T : iu32>(T) -> T */
     /* fn firstTrailingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[341],
+    /* overloads */ &kOverloads[344],
   },
   {
     /* [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[343],
+    /* overloads */ &kOverloads[346],
   },
   {
     /* [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[345],
+    /* overloads */ &kOverloads[348],
   },
   {
     /* [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[347],
+    /* overloads */ &kOverloads[350],
   },
   {
     /* [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[349],
+    /* overloads */ &kOverloads[352],
   },
   {
     /* [41] */
     /* fn fwidth(f32) -> f32 */
     /* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[351],
+    /* overloads */ &kOverloads[354],
   },
   {
     /* [42] */
     /* fn fwidthCoarse(f32) -> f32 */
     /* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[353],
+    /* overloads */ &kOverloads[356],
   },
   {
     /* [43] */
     /* fn fwidthFine(f32) -> f32 */
     /* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[355],
+    /* overloads */ &kOverloads[358],
   },
   {
     /* [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[357],
+    /* overloads */ &kOverloads[360],
   },
   {
     /* [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[359],
+    /* overloads */ &kOverloads[362],
   },
   {
     /* [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[361],
+    /* overloads */ &kOverloads[364],
   },
   {
     /* [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[363],
+    /* overloads */ &kOverloads[366],
   },
   {
     /* [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[365],
+    /* overloads */ &kOverloads[368],
   },
   {
     /* [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[367],
+    /* overloads */ &kOverloads[370],
   },
   {
     /* [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[369],
+    /* overloads */ &kOverloads[372],
   },
   {
     /* [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[371],
+    /* overloads */ &kOverloads[374],
   },
   {
     /* [52] */
@@ -14439,104 +14481,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[262],
+    /* overloads */ &kOverloads[265],
   },
   {
     /* [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[373],
+    /* overloads */ &kOverloads[376],
   },
   {
     /* [54] */
     /* fn normalize<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[440],
+    /* overloads */ &kOverloads[443],
   },
   {
     /* [55] */
     /* fn pack2x16float(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[441],
+    /* overloads */ &kOverloads[444],
   },
   {
     /* [56] */
     /* fn pack2x16snorm(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[442],
+    /* overloads */ &kOverloads[445],
   },
   {
     /* [57] */
     /* fn pack2x16unorm(vec2<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[443],
+    /* overloads */ &kOverloads[446],
   },
   {
     /* [58] */
     /* fn pack4x8snorm(vec4<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[444],
+    /* overloads */ &kOverloads[447],
   },
   {
     /* [59] */
     /* fn pack4x8unorm(vec4<f32>) -> u32 */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[445],
+    /* overloads */ &kOverloads[448],
   },
   {
     /* [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[375],
+    /* overloads */ &kOverloads[378],
   },
   {
     /* [61] */
     /* fn quantizeToF16(f32) -> f32 */
     /* fn quantizeToF16<N : num>(vec<N, f32>) -> vec<N, f32> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[377],
+    /* overloads */ &kOverloads[380],
   },
   {
     /* [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[379],
+    /* overloads */ &kOverloads[382],
   },
   {
     /* [63] */
     /* fn reflect<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[446],
+    /* overloads */ &kOverloads[449],
   },
   {
     /* [64] */
     /* fn refract<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[447],
+    /* overloads */ &kOverloads[450],
   },
   {
     /* [65] */
     /* fn reverseBits<T : iu32>(T) -> T */
     /* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[381],
+    /* overloads */ &kOverloads[384],
   },
   {
     /* [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[383],
+    /* overloads */ &kOverloads[386],
   },
   {
     /* [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[385],
+    /* overloads */ &kOverloads[388],
   },
   {
     /* [68] */
@@ -14544,124 +14586,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[265],
+    /* overloads */ &kOverloads[268],
   },
   {
     /* [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[387],
+    /* overloads */ &kOverloads[390],
   },
   {
     /* [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[389],
+    /* overloads */ &kOverloads[392],
   },
   {
     /* [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[391],
+    /* overloads */ &kOverloads[394],
   },
   {
     /* [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[393],
+    /* overloads */ &kOverloads[396],
   },
   {
     /* [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[395],
+    /* overloads */ &kOverloads[398],
   },
   {
     /* [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[397],
+    /* overloads */ &kOverloads[400],
   },
   {
     /* [75] */
     /* fn storageBarrier() */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[448],
+    /* overloads */ &kOverloads[451],
   },
   {
     /* [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[399],
+    /* overloads */ &kOverloads[402],
   },
   {
     /* [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[401],
+    /* overloads */ &kOverloads[404],
   },
   {
     /* [78] */
     /* fn transpose<M : num, N : num, T : fa_f32_f16>(mat<M, N, T>) -> mat<N, M, T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[449],
+    /* overloads */ &kOverloads[452],
   },
   {
     /* [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[403],
+    /* overloads */ &kOverloads[406],
   },
   {
     /* [80] */
     /* fn unpack2x16float(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[450],
+    /* overloads */ &kOverloads[453],
   },
   {
     /* [81] */
     /* fn unpack2x16snorm(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[451],
+    /* overloads */ &kOverloads[454],
   },
   {
     /* [82] */
     /* fn unpack2x16unorm(u32) -> vec2<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[452],
+    /* overloads */ &kOverloads[455],
   },
   {
     /* [83] */
     /* fn unpack4x8snorm(u32) -> vec4<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[453],
+    /* overloads */ &kOverloads[456],
   },
   {
     /* [84] */
     /* fn unpack4x8unorm(u32) -> vec4<f32> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[454],
+    /* overloads */ &kOverloads[457],
   },
   {
     /* [85] */
     /* fn workgroupBarrier() */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[455],
+    /* overloads */ &kOverloads[458],
   },
   {
     /* [86] */
     /* fn workgroupUniformLoad<T>(ptr<workgroup, T, read_write>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[456],
+    /* overloads */ &kOverloads[459],
   },
   {
     /* [87] */
@@ -14710,7 +14752,7 @@
     /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
     /* fn textureGather<A : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32> */
     /* num overloads */ 12,
-    /* overloads */ &kOverloads[71],
+    /* overloads */ &kOverloads[72],
   },
   {
     /* [89] */
@@ -14721,7 +14763,7 @@
     /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32> */
     /* fn textureGatherCompare<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[159],
+    /* overloads */ &kOverloads[162],
   },
   {
     /* [90] */
@@ -14731,7 +14773,7 @@
     /* 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 */ 5,
-    /* overloads */ &kOverloads[231],
+    /* overloads */ &kOverloads[234],
   },
   {
     /* [91] */
@@ -14746,14 +14788,14 @@
     /* fn textureNumLevels(texture: texture_depth_cube) -> u32 */
     /* fn textureNumLevels(texture: texture_depth_cube_array) -> u32 */
     /* num overloads */ 10,
-    /* overloads */ &kOverloads[106],
+    /* overloads */ &kOverloads[108],
   },
   {
     /* [92] */
     /* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> u32 */
     /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[405],
+    /* overloads */ &kOverloads[408],
   },
   {
     /* [93] */
@@ -14773,7 +14815,7 @@
     /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32 */
     /* fn textureSample<A : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32 */
     /* num overloads */ 15,
-    /* overloads */ &kOverloads[27],
+    /* overloads */ &kOverloads[43],
   },
   {
     /* [94] */
@@ -14786,7 +14828,7 @@
     /* fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> */
     /* fn textureSampleBias<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32> */
     /* num overloads */ 8,
-    /* overloads */ &kOverloads[143],
+    /* overloads */ &kOverloads[146],
   },
   {
     /* [95] */
@@ -14797,7 +14839,7 @@
     /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
     /* fn textureSampleCompare<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[165],
+    /* overloads */ &kOverloads[168],
   },
   {
     /* [96] */
@@ -14808,7 +14850,7 @@
     /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
     /* fn textureSampleCompareLevel<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[171],
+    /* overloads */ &kOverloads[174],
   },
   {
     /* [97] */
@@ -14821,7 +14863,7 @@
     /* fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
     /* fn textureSampleGrad<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
     /* num overloads */ 8,
-    /* overloads */ &kOverloads[151],
+    /* overloads */ &kOverloads[154],
   },
   {
     /* [98] */
@@ -14840,14 +14882,14 @@
     /* fn textureSampleLevel<L : iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32 */
     /* fn textureSampleLevel<A : iu32, L : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32 */
     /* num overloads */ 14,
-    /* overloads */ &kOverloads[57],
+    /* overloads */ &kOverloads[58],
   },
   {
     /* [99] */
     /* 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[407],
+    /* overloads */ &kOverloads[410],
   },
   {
     /* [100] */
@@ -14864,7 +14906,7 @@
     /* fn textureStore<C : iu32, A : iu32>(texture: texture_storage_2d_array<u32_texel_format, write>, coords: vec2<C>, array_index: A, value: vec4<u32>) */
     /* fn textureStore<C : iu32>(texture: texture_storage_3d<u32_texel_format, write>, coords: vec3<C>, value: vec4<u32>) */
     /* num overloads */ 12,
-    /* overloads */ &kOverloads[83],
+    /* overloads */ &kOverloads[84],
   },
   {
     /* [101] */
@@ -14878,79 +14920,79 @@
     /* fn textureLoad<C : iu32, S : iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32 */
     /* fn textureLoad<C : iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32> */
     /* num overloads */ 9,
-    /* overloads */ &kOverloads[116],
+    /* overloads */ &kOverloads[128],
   },
   {
     /* [102] */
     /* fn atomicLoad<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[457],
+    /* overloads */ &kOverloads[460],
   },
   {
     /* [103] */
     /* fn atomicStore<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[458],
+    /* overloads */ &kOverloads[461],
   },
   {
     /* [104] */
     /* fn atomicAdd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[459],
+    /* overloads */ &kOverloads[462],
   },
   {
     /* [105] */
     /* fn atomicSub<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[460],
+    /* overloads */ &kOverloads[463],
   },
   {
     /* [106] */
     /* fn atomicMax<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[461],
+    /* overloads */ &kOverloads[464],
   },
   {
     /* [107] */
     /* fn atomicMin<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[462],
+    /* overloads */ &kOverloads[465],
   },
   {
     /* [108] */
     /* fn atomicAnd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[463],
+    /* overloads */ &kOverloads[466],
   },
   {
     /* [109] */
     /* fn atomicOr<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[464],
+    /* overloads */ &kOverloads[467],
   },
   {
     /* [110] */
     /* fn atomicXor<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[465],
+    /* overloads */ &kOverloads[468],
   },
   {
     /* [111] */
     /* fn atomicExchange<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[466],
+    /* overloads */ &kOverloads[469],
   },
   {
     /* [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[467],
+    /* overloads */ &kOverloads[470],
   },
   {
     /* [113] */
     /* fn _tint_materialize<T>(T) -> T */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[468],
+    /* overloads */ &kOverloads[471],
   },
 };
 
@@ -14960,21 +15002,21 @@
     /* op !(bool) -> bool */
     /* op !<N : num>(vec<N, bool>) -> vec<N, bool> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[409],
+    /* overloads */ &kOverloads[412],
   },
   {
     /* [1] */
     /* op ~<T : ia_iu32>(T) -> T */
     /* op ~<T : ia_iu32, N : num>(vec<N, T>) -> vec<N, T> */
     /* num overloads */ 2,
-    /* overloads */ &kOverloads[411],
+    /* overloads */ &kOverloads[414],
   },
   {
     /* [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[413],
+    /* overloads */ &kOverloads[416],
   },
 };
 constexpr uint8_t kUnaryOperatorNot = 0;
@@ -14990,7 +15032,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[239],
   },
   {
     /* [1] */
@@ -15000,7 +15042,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[241],
+    /* overloads */ &kOverloads[244],
   },
   {
     /* [2] */
@@ -15014,7 +15056,7 @@
     /* op *<T : fa_f32_f16, C : num, R : num>(vec<R, T>, mat<C, R, T>) -> vec<C, T> */
     /* op *<T : fa_f32_f16, K : num, C : num, R : num>(mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T> */
     /* num overloads */ 9,
-    /* overloads */ &kOverloads[125],
+    /* overloads */ &kOverloads[137],
   },
   {
     /* [3] */
@@ -15023,7 +15065,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[246],
+    /* overloads */ &kOverloads[249],
   },
   {
     /* [4] */
@@ -15032,14 +15074,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[250],
+    /* overloads */ &kOverloads[253],
   },
   {
     /* [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[415],
+    /* overloads */ &kOverloads[418],
   },
   {
     /* [6] */
@@ -15048,7 +15090,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[254],
+    /* overloads */ &kOverloads[257],
   },
   {
     /* [7] */
@@ -15057,75 +15099,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[258],
+    /* overloads */ &kOverloads[261],
   },
   {
     /* [8] */
     /* op &&(bool, bool) -> bool */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[469],
+    /* overloads */ &kOverloads[472],
   },
   {
     /* [9] */
     /* op ||(bool, bool) -> bool */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[470],
+    /* overloads */ &kOverloads[473],
   },
   {
     /* [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[417],
+    /* overloads */ &kOverloads[420],
   },
   {
     /* [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[419],
+    /* overloads */ &kOverloads[422],
   },
   {
     /* [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[421],
+    /* overloads */ &kOverloads[424],
   },
   {
     /* [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[423],
+    /* overloads */ &kOverloads[426],
   },
   {
     /* [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[425],
+    /* overloads */ &kOverloads[428],
   },
   {
     /* [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[427],
+    /* overloads */ &kOverloads[430],
   },
   {
     /* [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[429],
+    /* overloads */ &kOverloads[432],
   },
   {
     /* [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[431],
+    /* overloads */ &kOverloads[434],
   },
 };
 constexpr uint8_t kBinaryOperatorPlus = 0;
@@ -15154,7 +15196,7 @@
     /* ctor i32(i32) -> i32 */
     /* conv i32<T : scalar_no_i32>(T) -> i32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[268],
+    /* overloads */ &kOverloads[271],
   },
   {
     /* [1] */
@@ -15162,7 +15204,7 @@
     /* ctor u32(u32) -> u32 */
     /* conv u32<T : scalar_no_u32>(T) -> u32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[271],
+    /* overloads */ &kOverloads[274],
   },
   {
     /* [2] */
@@ -15170,7 +15212,7 @@
     /* ctor f32(f32) -> f32 */
     /* conv f32<T : scalar_no_f32>(T) -> f32 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[274],
+    /* overloads */ &kOverloads[277],
   },
   {
     /* [3] */
@@ -15178,7 +15220,7 @@
     /* ctor f16(f16) -> f16 */
     /* conv f16<T : scalar_no_f16>(T) -> f16 */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[277],
+    /* overloads */ &kOverloads[280],
   },
   {
     /* [4] */
@@ -15186,10 +15228,11 @@
     /* ctor bool(bool) -> bool */
     /* conv bool<T : scalar_no_bool>(T) -> bool */
     /* num overloads */ 3,
-    /* overloads */ &kOverloads[280],
+    /* overloads */ &kOverloads[283],
   },
   {
     /* [5] */
+    /* ctor vec2() -> vec2<ia> */
     /* ctor vec2<T : concrete_scalar>() -> vec2<T> */
     /* ctor vec2<T : scalar>(vec2<T>) -> vec2<T> */
     /* ctor vec2<T : scalar>(T) -> vec2<T> */
@@ -15199,11 +15242,12 @@
     /* conv vec2<T : i32, U : scalar_no_i32>(vec2<U>) -> vec2<i32> */
     /* conv vec2<T : u32, U : scalar_no_u32>(vec2<U>) -> vec2<u32> */
     /* conv vec2<T : bool, U : scalar_no_bool>(vec2<U>) -> vec2<bool> */
-    /* num overloads */ 9,
-    /* overloads */ &kOverloads[134],
+    /* num overloads */ 10,
+    /* overloads */ &kOverloads[118],
   },
   {
     /* [6] */
+    /* ctor vec3() -> vec3<ia> */
     /* ctor vec3<T : concrete_scalar>() -> vec3<T> */
     /* ctor vec3<T : scalar>(vec3<T>) -> vec3<T> */
     /* ctor vec3<T : scalar>(T) -> vec3<T> */
@@ -15215,11 +15259,12 @@
     /* conv vec3<T : i32, U : scalar_no_i32>(vec3<U>) -> vec3<i32> */
     /* conv vec3<T : u32, U : scalar_no_u32>(vec3<U>) -> vec3<u32> */
     /* conv vec3<T : bool, U : scalar_no_bool>(vec3<U>) -> vec3<bool> */
-    /* num overloads */ 11,
-    /* overloads */ &kOverloads[95],
+    /* num overloads */ 12,
+    /* overloads */ &kOverloads[96],
   },
   {
     /* [7] */
+    /* ctor vec4() -> vec4<ia> */
     /* ctor vec4<T : concrete_scalar>() -> vec4<T> */
     /* ctor vec4<T : scalar>(vec4<T>) -> vec4<T> */
     /* ctor vec4<T : scalar>(T) -> vec4<T> */
@@ -15235,8 +15280,8 @@
     /* conv vec4<T : i32, U : scalar_no_i32>(vec4<U>) -> vec4<i32> */
     /* conv vec4<T : u32, U : scalar_no_u32>(vec4<U>) -> vec4<u32> */
     /* conv vec4<T : bool, U : scalar_no_bool>(vec4<U>) -> vec4<bool> */
-    /* num overloads */ 15,
-    /* overloads */ &kOverloads[42],
+    /* num overloads */ 16,
+    /* overloads */ &kOverloads[27],
   },
   {
     /* [8] */
@@ -15247,7 +15292,7 @@
     /* conv mat2x2<T : f16>(mat2x2<f32>) -> mat2x2<f16> */
     /* conv mat2x2<T : f32>(mat2x2<f16>) -> mat2x2<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[177],
+    /* overloads */ &kOverloads[180],
   },
   {
     /* [9] */
@@ -15258,7 +15303,7 @@
     /* conv mat2x3<T : f16>(mat2x3<f32>) -> mat2x3<f16> */
     /* conv mat2x3<T : f32>(mat2x3<f16>) -> mat2x3<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[183],
+    /* overloads */ &kOverloads[186],
   },
   {
     /* [10] */
@@ -15269,7 +15314,7 @@
     /* conv mat2x4<T : f16>(mat2x4<f32>) -> mat2x4<f16> */
     /* conv mat2x4<T : f32>(mat2x4<f16>) -> mat2x4<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[189],
+    /* overloads */ &kOverloads[192],
   },
   {
     /* [11] */
@@ -15280,7 +15325,7 @@
     /* conv mat3x2<T : f16>(mat3x2<f32>) -> mat3x2<f16> */
     /* conv mat3x2<T : f32>(mat3x2<f16>) -> mat3x2<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[195],
+    /* overloads */ &kOverloads[198],
   },
   {
     /* [12] */
@@ -15291,7 +15336,7 @@
     /* conv mat3x3<T : f16>(mat3x3<f32>) -> mat3x3<f16> */
     /* conv mat3x3<T : f32>(mat3x3<f16>) -> mat3x3<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[201],
+    /* overloads */ &kOverloads[204],
   },
   {
     /* [13] */
@@ -15302,7 +15347,7 @@
     /* conv mat3x4<T : f16>(mat3x4<f32>) -> mat3x4<f16> */
     /* conv mat3x4<T : f32>(mat3x4<f16>) -> mat3x4<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[207],
+    /* overloads */ &kOverloads[210],
   },
   {
     /* [14] */
@@ -15313,7 +15358,7 @@
     /* conv mat4x2<T : f16>(mat4x2<f32>) -> mat4x2<f16> */
     /* conv mat4x2<T : f32>(mat4x2<f16>) -> mat4x2<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[213],
+    /* overloads */ &kOverloads[216],
   },
   {
     /* [15] */
@@ -15324,7 +15369,7 @@
     /* conv mat4x3<T : f16>(mat4x3<f32>) -> mat4x3<f16> */
     /* conv mat4x3<T : f32>(mat4x3<f16>) -> mat4x3<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[219],
+    /* overloads */ &kOverloads[222],
   },
   {
     /* [16] */
@@ -15335,13 +15380,13 @@
     /* conv mat4x4<T : f16>(mat4x4<f32>) -> mat4x4<f16> */
     /* conv mat4x4<T : f32>(mat4x4<f16>) -> mat4x4<f32> */
     /* num overloads */ 6,
-    /* overloads */ &kOverloads[225],
+    /* overloads */ &kOverloads[228],
   },
   {
     /* [17] */
     /* conv packedVec3<T : concrete_scalar>(vec3<T>) -> packedVec3<T> */
     /* num overloads */ 1,
-    /* overloads */ &kOverloads[471],
+    /* overloads */ &kOverloads[474],
   },
 };
 
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index c842af5..19ead21 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -841,12 +841,13 @@
     EXPECT_EQ(Diagnostics().str(),
               R"(12:34 error: no matching constructor for vec3(i32, f32, i32)
 
-6 candidate constructors:
+7 candidate constructors:
   vec3(x: T, y: T, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(xy: vec2<T>, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(x: T, yz: vec2<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(vec3<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
+  vec3() -> vec3<abstract-int>
   vec3<T>() -> vec3<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
@@ -867,12 +868,13 @@
     EXPECT_EQ(Diagnostics().str(),
               R"(12:34 error: no matching constructor for vec3<i32>(i32, f32, i32)
 
-6 candidate constructors:
+7 candidate constructors:
   vec3(x: T, y: T, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(x: T, yz: vec2<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(xy: vec2<T>, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(vec3<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
+  vec3() -> vec3<abstract-int>
   vec3<T>() -> vec3<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
@@ -971,9 +973,10 @@
     EXPECT_EQ(Diagnostics().str(),
               R"(12:34 error: no matching constructor for vec3<f32>(array<u32>)
 
-6 candidate constructors:
+7 candidate constructors:
   vec3(vec3<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
+  vec3() -> vec3<abstract-int>
   vec3<T>() -> vec3<T>  where: T is f32, f16, i32, u32 or bool
   vec3(xy: vec2<T>, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
   vec3(x: T, yz: vec2<T>) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 1ec680d..19571a7 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -3466,15 +3466,33 @@
 
 bool Resolver::DiagnosticControl(const ast::DiagnosticControl& control) {
     Mark(control.rule_name);
+    Mark(control.rule_name->name);
+    auto name = control.rule_name->name->symbol.Name();
 
-    auto rule_name = control.rule_name->symbol.Name();
-    auto rule = builtin::ParseDiagnosticRule(rule_name);
-    if (rule != builtin::DiagnosticRule::kUndefined) {
+    if (control.rule_name->category) {
+        Mark(control.rule_name->category);
+        if (control.rule_name->category->symbol.Name() == "chromium") {
+            auto rule = builtin::ParseChromiumDiagnosticRule(name);
+            if (rule != builtin::ChromiumDiagnosticRule::kUndefined) {
+                validator_.DiagnosticFilters().Set(rule, control.severity);
+            } else {
+                utils::StringStream ss;
+                ss << "unrecognized diagnostic rule 'chromium." << name << "'\n";
+                utils::SuggestAlternatives(name, builtin::kChromiumDiagnosticRuleStrings, ss,
+                                           "chromium.");
+                AddWarning(ss.str(), control.rule_name->source);
+            }
+        }
+        return true;
+    }
+
+    auto rule = builtin::ParseCoreDiagnosticRule(name);
+    if (rule != builtin::CoreDiagnosticRule::kUndefined) {
         validator_.DiagnosticFilters().Set(rule, control.severity);
     } else {
         utils::StringStream ss;
-        ss << "unrecognized diagnostic rule '" << rule_name << "'\n";
-        utils::SuggestAlternatives(rule_name, builtin::kDiagnosticRuleStrings, ss);
+        ss << "unrecognized diagnostic rule '" << name << "'\n";
+        utils::SuggestAlternatives(name, builtin::kCoreDiagnosticRuleStrings, ss);
         AddWarning(ss.str(), control.rule_name->source);
     }
     return true;
diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc
index fc84826..45c919e 100644
--- a/src/tint/resolver/uniformity.cc
+++ b/src/tint/resolver/uniformity.cc
@@ -1563,7 +1563,7 @@
                            builtin->Type() == builtin::Function::kTextureSampleCompare) {
                     // Get the severity of derivative uniformity violations in this context.
                     auto severity = sem_.DiagnosticSeverity(
-                        call, builtin::DiagnosticRule::kDerivativeUniformity);
+                        call, builtin::CoreDiagnosticRule::kDerivativeUniformity);
                     if (severity != builtin::DiagnosticSeverity::kOff) {
                         callsite_tag = {CallSiteTag::CallSiteRequiredToBeUniform, severity};
                     }
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index f72000b..97eae88 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -159,9 +159,9 @@
       atomic_composite_info_(atomic_composite_info),
       valid_type_storage_layouts_(valid_type_storage_layouts) {
     // Set default severities for filterable diagnostic rules.
-    diagnostic_filters_.Set(builtin::DiagnosticRule::kDerivativeUniformity,
+    diagnostic_filters_.Set(builtin::CoreDiagnosticRule::kDerivativeUniformity,
                             builtin::DiagnosticSeverity::kError);
-    diagnostic_filters_.Set(builtin::DiagnosticRule::kChromiumUnreachableCode,
+    diagnostic_filters_.Set(builtin::ChromiumDiagnosticRule::kUnreachableCode,
                             builtin::DiagnosticSeverity::kWarning);
 }
 
@@ -1417,7 +1417,7 @@
 bool Validator::Statements(utils::VectorRef<const ast::Statement*> stmts) const {
     for (auto* stmt : stmts) {
         if (!sem_.Get(stmt)->IsReachable()) {
-            if (!AddDiagnostic(builtin::DiagnosticRule::kChromiumUnreachableCode,
+            if (!AddDiagnostic(builtin::ChromiumDiagnosticRule::kUnreachableCode,
                                "code is unreachable", stmt->source)) {
                 return false;
             }
@@ -2530,9 +2530,12 @@
                                    const char* use) const {
     // Make sure that no two diagnostic controls conflict.
     // They conflict if the rule name is the same and the severity is different.
-    utils::Hashmap<Symbol, const ast::DiagnosticControl*, 8> diagnostics;
+    utils::Hashmap<std::pair<Symbol, Symbol>, const ast::DiagnosticControl*, 8> diagnostics;
     for (auto* dc : controls) {
-        auto diag_added = diagnostics.Add(dc->rule_name->symbol, dc);
+        auto category = dc->rule_name->category ? dc->rule_name->category->symbol : Symbol();
+        auto name = dc->rule_name->name->symbol;
+
+        auto diag_added = diagnostics.Add(std::make_pair(category, name), dc);
         if (!diag_added && (*diag_added.value)->severity != dc->severity) {
             {
                 utils::StringStream ss;
@@ -2541,8 +2544,8 @@
             }
             {
                 utils::StringStream ss;
-                ss << "severity of '" << dc->rule_name->symbol.Name() << "' set to '"
-                   << dc->severity << "' here";
+                ss << "severity of '" << dc->rule_name->String() << "' set to '" << dc->severity
+                   << "' here";
                 AddNote(ss.str(), (*diag_added.value)->rule_name->source);
             }
             return false;
diff --git a/src/tint/resolver/value_constructor_validation_test.cc b/src/tint/resolver/value_constructor_validation_test.cc
index 21603fe..772b9c1 100644
--- a/src/tint/resolver/value_constructor_validation_test.cc
+++ b/src/tint/resolver/value_constructor_validation_test.cc
@@ -2299,11 +2299,26 @@
     EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
 }
 
-TEST_F(ResolverValueConstructorValidationTest, CannotInferVectorElementTypeWithoutArgs) {
-    WrapInFunction(Call(Source{{12, 34}}, "vec3"));
+TEST_F(ResolverValueConstructorValidationTest, InferVecNoArgs) {
+    auto* v2 = vec2<Infer>();
+    auto* v3 = vec3<Infer>();
+    auto* v4 = vec4<Infer>();
 
-    EXPECT_FALSE(r()->Resolve());
-    EXPECT_THAT(r()->error(), HasSubstr("12:34 error: no matching constructor for vec3()"));
+    GlobalConst("v2", v2);
+    GlobalConst("v3", v3);
+    GlobalConst("v4", v4);
+
+    ASSERT_TRUE(r()->Resolve()) << r()->error();
+
+    ASSERT_TRUE(TypeOf(v2)->Is<type::Vector>());
+    ASSERT_TRUE(TypeOf(v3)->Is<type::Vector>());
+    ASSERT_TRUE(TypeOf(v4)->Is<type::Vector>());
+    EXPECT_TRUE(TypeOf(v2)->As<type::Vector>()->type()->Is<type::AbstractInt>());
+    EXPECT_TRUE(TypeOf(v3)->As<type::Vector>()->type()->Is<type::AbstractInt>());
+    EXPECT_TRUE(TypeOf(v4)->As<type::Vector>()->type()->Is<type::AbstractInt>());
+    EXPECT_EQ(TypeOf(v2)->As<type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(v3)->As<type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(v4)->As<type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, CannotInferVec2ElementTypeFromScalarsMismatch) {
diff --git a/src/tint/sem/diagnostic_severity_test.cc b/src/tint/sem/diagnostic_severity_test.cc
index 9d36ea2..a378add 100644
--- a/src/tint/sem/diagnostic_severity_test.cc
+++ b/src/tint/sem/diagnostic_severity_test.cc
@@ -23,27 +23,27 @@
 
 class DiagnosticSeverityTest : public TestHelper {
   protected:
-    /// Create a program with two functions, setting the severity for "chromium_unreachable_code"
+    /// Create a program with two functions, setting the severity for "chromium.unreachable_code"
     /// using an attribute. Test that we correctly track the severity of the filter for the
     /// functions and the statements with them.
-    /// @param global_severity the global severity of the "chromium_unreachable_code" filter
+    /// @param global_severity the global severity of the "chromium.unreachable_code" filter
     void Run(builtin::DiagnosticSeverity global_severity) {
-        // @diagnostic(off, chromium_unreachable_code)
+        // @diagnostic(off, chromium.unreachable_code)
         // fn foo() {
-        //   @diagnostic(info, chromium_unreachable_code) {
-        //     @diagnostic(error, chromium_unreachable_code)
-        //     if (true) @diagnostic(warning, chromium_unreachable_code) {
+        //   @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) {
+        //     } else @diagnostic(info, chromium.unreachable_code) {
         //       return;
         //     }
         //     return;
         //
-        //     @diagnostic(error, chromium_unreachable_code)
-        //     switch (42) @diagnostic(off, chromium_unreachable_code) {
-        //       case 0 @diagnostic(warning, chromium_unreachable_code) {
+        //     @diagnostic(error, chromium.unreachable_code)
+        //     switch (42) @diagnostic(off, chromium.unreachable_code) {
+        //       case 0 @diagnostic(warning, chromium.unreachable_code) {
         //         return;
         //       }
         //       default {
@@ -51,21 +51,21 @@
         //       }
         //     }
         //
-        //     @diagnostic(error, chromium_unreachable_code)
-        //     for (var i = 0; false; i++) @diagnostic(warning, chromium_unreachable_code) {
+        //     @diagnostic(error, chromium.unreachable_code)
+        //     for (var i = 0; false; i++) @diagnostic(warning, chromium.unreachable_code) {
         //       return;
         //     }
         //
-        //     @diagnostic(warning, chromium_unreachable_code)
-        //     loop @diagnostic(off, chromium_unreachable_code) {
+        //     @diagnostic(warning, chromium.unreachable_code)
+        //     loop @diagnostic(off, chromium.unreachable_code) {
         //       return;
-        //       continuing @diagnostic(info, chromium_unreachable_code) {
+        //       continuing @diagnostic(info, chromium.unreachable_code) {
         //         break if true;
         //       }
         //     }
         //
-        //     @diagnostic(error, chromium_unreachable_code)
-        //     while (false) @diagnostic(warning, chromium_unreachable_code) {
+        //     @diagnostic(error, chromium.unreachable_code)
+        //     while (false) @diagnostic(warning, chromium.unreachable_code) {
         //       return;
         //     }
         //   }
@@ -74,7 +74,7 @@
         // fn bar() {
         //   return;
         // }
-        auto rule = builtin::DiagnosticRule::kChromiumUnreachableCode;
+        auto rule = builtin::ChromiumDiagnosticRule::kUnreachableCode;
         auto func_severity = builtin::DiagnosticSeverity::kOff;
         auto block_severity = builtin::DiagnosticSeverity::kInfo;
         auto if_severity = builtin::DiagnosticSeverity::kError;
@@ -91,7 +91,7 @@
         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")};
+            return utils::Vector{DiagnosticAttribute(severity, "chromium", "unreachable_code")};
         };
 
         auto* return_foo_if = Return();
@@ -123,7 +123,7 @@
                          attr(while_severity));
         auto* block_1 =
             Block(utils::Vector{if_foo, return_foo_block, swtch, fl, l, wl}, attr(block_severity));
-        auto* func_attr = DiagnosticAttribute(func_severity, "chromium_unreachable_code");
+        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_bar = Return();
@@ -173,7 +173,7 @@
 };
 
 TEST_F(DiagnosticSeverityTest, WithDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
     Run(builtin::DiagnosticSeverity::kError);
 }
 
diff --git a/src/tint/symbol.cc b/src/tint/symbol.cc
index 7e69b5d..ad84add 100644
--- a/src/tint/symbol.cc
+++ b/src/tint/symbol.cc
@@ -21,7 +21,9 @@
 Symbol::Symbol() = default;
 
 Symbol::Symbol(uint32_t val, tint::ProgramID pid, std::string_view name)
-    : val_(val), program_id_(pid), name_(name) {}
+    : val_(val), program_id_(pid), name_(name) {
+    DetermineBuiltinType();
+}
 
 Symbol::Symbol(const Symbol& o) = default;
 
@@ -60,4 +62,51 @@
     return std::string(name_);
 }
 
+void Symbol::DetermineBuiltinType() {
+    if (auto builtin_fn = builtin::ParseFunction(name_); builtin_fn != builtin::Function::kNone) {
+        builtin_type_ = BuiltinType::kFunction;
+        builtin_value_ = builtin_fn;
+        return;
+    }
+    if (auto builtin_ty = builtin::ParseBuiltin(name_);
+        builtin_ty != builtin::Builtin::kUndefined) {
+        builtin_type_ = BuiltinType::kBuiltin;
+        builtin_value_ = builtin_ty;
+        return;
+    }
+    if (auto builtin_val = builtin::ParseBuiltinValue(name_);
+        builtin_val != builtin::BuiltinValue::kUndefined) {
+        builtin_type_ = BuiltinType::kBuiltinValue;
+        builtin_value_ = builtin_val;
+        return;
+    }
+    if (auto addr = builtin::ParseAddressSpace(name_); addr != builtin::AddressSpace::kUndefined) {
+        builtin_type_ = BuiltinType::kAddressSpace;
+        builtin_value_ = addr;
+        return;
+    }
+    if (auto fmt = builtin::ParseTexelFormat(name_); fmt != builtin::TexelFormat::kUndefined) {
+        builtin_type_ = BuiltinType::kTexelFormat;
+        builtin_value_ = fmt;
+        return;
+    }
+    if (auto access = builtin::ParseAccess(name_); access != builtin::Access::kUndefined) {
+        builtin_type_ = BuiltinType::kAccess;
+        builtin_value_ = access;
+        return;
+    }
+    if (auto i_type = builtin::ParseInterpolationType(name_);
+        i_type != builtin::InterpolationType::kUndefined) {
+        builtin_type_ = BuiltinType::kInterpolationType;
+        builtin_value_ = i_type;
+        return;
+    }
+    if (auto i_smpl = builtin::ParseInterpolationSampling(name_);
+        i_smpl != builtin::InterpolationSampling::kUndefined) {
+        builtin_type_ = BuiltinType::kInterpolationSampling;
+        builtin_value_ = i_smpl;
+        return;
+    }
+}
+
 }  // namespace tint
diff --git a/src/tint/symbol.h b/src/tint/symbol.h
index 16d8409..ae29559 100644
--- a/src/tint/symbol.h
+++ b/src/tint/symbol.h
@@ -16,7 +16,16 @@
 #define SRC_TINT_SYMBOL_H_
 
 #include <string>
+#include <variant>
 
+#include "src/tint/builtin/access.h"
+#include "src/tint/builtin/address_space.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/program_id.h"
 
 namespace tint {
@@ -24,6 +33,28 @@
 /// A symbol representing a string in the system
 class Symbol {
   public:
+    /// The type of builtin this symbol could represent, if any.
+    enum class BuiltinType {
+        /// No builtin matched
+        kNone = 0,
+        /// Builtin function
+        kFunction,
+        /// Builtin
+        kBuiltin,
+        /// Builtin value
+        kBuiltinValue,
+        /// Address space
+        kAddressSpace,
+        /// Texel format
+        kTexelFormat,
+        /// Access
+        kAccess,
+        /// Interpolation Type
+        kInterpolationType,
+        /// Interpolation Sampling
+        kInterpolationSampling,
+    };
+
     /// Constructor
     /// An invalid symbol
     Symbol();
@@ -87,10 +118,33 @@
     /// @returns the identifier of the Program that owns this symbol.
     tint::ProgramID ProgramID() const { return program_id_; }
 
+    /// @returns the builtin type
+    BuiltinType Type() const { return builtin_type_; }
+
+    /// @returns the builtin value
+    template <typename T>
+    T BuiltinValue() const {
+        return std::get<T>(builtin_value_);
+    }
+
   private:
+    void DetermineBuiltinType();
+
     uint32_t val_ = static_cast<uint32_t>(-1);
     tint::ProgramID program_id_;
     std::string_view name_;
+
+    BuiltinType builtin_type_ = BuiltinType::kNone;
+    std::variant<std::monostate,
+                 builtin::Function,
+                 builtin::Builtin,
+                 builtin::BuiltinValue,
+                 builtin::AddressSpace,
+                 builtin::TexelFormat,
+                 builtin::Access,
+                 builtin::InterpolationType,
+                 builtin::InterpolationSampling>
+        builtin_value_ = {};
 };
 
 /// @param sym the Symbol
diff --git a/src/tint/transform/renamer.cc b/src/tint/transform/renamer.cc
index bd74cf6..14b8c12 100644
--- a/src/tint/transform/renamer.cc
+++ b/src/tint/transform/renamer.cc
@@ -1289,10 +1289,16 @@
                 }
             },
             [&](const ast::DiagnosticAttribute* diagnostic) {
-                preserved_identifiers.Add(diagnostic->control.rule_name);
+                if (auto* category = diagnostic->control.rule_name->category) {
+                    preserved_identifiers.Add(category);
+                }
+                preserved_identifiers.Add(diagnostic->control.rule_name->name);
             },
             [&](const ast::DiagnosticDirective* diagnostic) {
-                preserved_identifiers.Add(diagnostic->control.rule_name);
+                if (auto* category = diagnostic->control.rule_name->category) {
+                    preserved_identifiers.Add(category);
+                }
+                preserved_identifiers.Add(diagnostic->control.rule_name->name);
             },
             [&](const ast::IdentifierExpression* expr) {
                 Switch(
diff --git a/src/tint/transform/renamer_test.cc b/src/tint/transform/renamer_test.cc
index fc34251..cd321fb 100644
--- a/src/tint/transform/renamer_test.cc
+++ b/src/tint/transform/renamer_test.cc
@@ -192,9 +192,9 @@
     EXPECT_THAT(data->remappings, ContainerEq(expected_remappings));
 }
 
-TEST_F(RenamerTest, PreserveDiagnosticControls) {
+TEST_F(RenamerTest, PreserveCoreDiagnosticRuleName) {
     auto* src = R"(
-diagnostic(off, unreachable_code);
+diagnostic(off, chromium.unreachable_code);
 
 @diagnostic(off, derivative_uniformity)
 @fragment
@@ -208,7 +208,7 @@
 )";
 
     auto* expect = R"(
-diagnostic(off, unreachable_code);
+diagnostic(off, chromium.unreachable_code);
 
 @diagnostic(off, derivative_uniformity) @fragment
 fn tint_symbol(@location(0) tint_symbol_1 : f32) -> @location(0) f32 {
diff --git a/src/tint/utils/hash.h b/src/tint/utils/hash.h
index 8c9dd25..a63a303 100644
--- a/src/tint/utils/hash.h
+++ b/src/tint/utils/hash.h
@@ -134,7 +134,15 @@
     }
 };
 
-/// Hasher specialization for std::tuple
+/// Hasher specialization for std::pair
+template <typename A, typename B>
+struct Hasher<std::pair<A, B>> {
+    /// @param tuple the tuple to hash
+    /// @returns a hash of the tuple
+    size_t operator()(const std::pair<A, B>& tuple) const { return std::apply(Hash<A, B>, tuple); }
+};
+
+/// Hasher specialization for std::variant
 template <typename... TYPES>
 struct Hasher<std::variant<TYPES...>> {
     /// @param variant the variant to hash
diff --git a/src/tint/utils/math.h b/src/tint/utils/math.h
index c10a2c9..311ec16 100644
--- a/src/tint/utils/math.h
+++ b/src/tint/utils/math.h
@@ -15,6 +15,8 @@
 #ifndef SRC_TINT_UTILS_MATH_H_
 #define SRC_TINT_UTILS_MATH_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <type_traits>
 
diff --git a/src/tint/utils/string.cc b/src/tint/utils/string.cc
index 2f28a3e..67eaf2b 100644
--- a/src/tint/utils/string.cc
+++ b/src/tint/utils/string.cc
@@ -50,7 +50,8 @@
 
 void SuggestAlternatives(std::string_view got,
                          Slice<char const* const> strings,
-                         utils::StringStream& ss) {
+                         utils::StringStream& ss,
+                         std::string_view prefix /* = "" */) {
     // If the string typed was within kSuggestionDistance of one of the possible enum values,
     // suggest that. Don't bother with suggestions if the string was extremely long.
     constexpr size_t kSuggestionDistance = 5;
@@ -66,7 +67,7 @@
             }
         }
         if (candidate) {
-            ss << "Did you mean '" << candidate << "'?\n";
+            ss << "Did you mean '" << prefix << candidate << "'?\n";
         }
     }
 
@@ -76,7 +77,7 @@
         if (str != strings[0]) {
             ss << ", ";
         }
-        ss << "'" << str << "'";
+        ss << "'" << prefix << str << "'";
     }
 }
 
diff --git a/src/tint/utils/string.h b/src/tint/utils/string.h
index 5c7255d..897d1a1 100644
--- a/src/tint/utils/string.h
+++ b/src/tint/utils/string.h
@@ -72,9 +72,11 @@
 /// @param got the unrecognized string
 /// @param strings the list of possible values
 /// @param ss the stream to write the suggest and list of possible values to
+/// @param prefix the prefix to apply to the strings when printing (optional)
 void SuggestAlternatives(std::string_view got,
                          Slice<char const* const> strings,
-                         utils::StringStream& ss);
+                         utils::StringStream& ss,
+                         std::string_view prefix = "");
 
 }  // namespace tint::utils
 
diff --git a/src/tint/utils/unicode.cc b/src/tint/utils/unicode.cc
index 65a003a..eac220c 100644
--- a/src/tint/utils/unicode.cc
+++ b/src/tint/utils/unicode.cc
@@ -336,6 +336,10 @@
     if (len < 1) {
         return {};
     }
+    // Fast-path ASCII characters as they're always valid
+    if (ptr[0] <= 0x7f) {
+        return {CodePoint{ptr[0]}, 1};
+    }
 
     // Lookup table for the first byte of a UTF-8 sequence.
     // 0 indicates an invalid length.
diff --git a/src/tint/writer/syntax_tree/generator_impl.cc b/src/tint/writer/syntax_tree/generator_impl.cc
index be30289..08ca8c5 100644
--- a/src/tint/writer/syntax_tree/generator_impl.cc
+++ b/src/tint/writer/syntax_tree/generator_impl.cc
@@ -66,7 +66,7 @@
 
 void GeneratorImpl::EmitDiagnosticControl(const ast::DiagnosticControl& diagnostic) {
     line() << "DiagnosticControl [severity: " << diagnostic.severity
-           << ", rule: " << diagnostic.rule_name->symbol.Name() << "]";
+           << ", rule: " << diagnostic.rule_name->String() << "]";
 }
 
 void GeneratorImpl::EmitEnable(const ast::Enable* enable) {
diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc
index 2a2f0e7..2703e8d 100644
--- a/src/tint/writer/wgsl/generator_impl.cc
+++ b/src/tint/writer/wgsl/generator_impl.cc
@@ -82,8 +82,7 @@
 
 void GeneratorImpl::EmitDiagnosticControl(utils::StringStream& out,
                                           const ast::DiagnosticControl& diagnostic) {
-    out << "diagnostic(" << diagnostic.severity << ", " << diagnostic.rule_name->symbol.Name()
-        << ")";
+    out << "diagnostic(" << diagnostic.severity << ", " << diagnostic.rule_name->String() << ")";
 }
 
 void GeneratorImpl::EmitEnable(const ast::Enable* enable) {
diff --git a/src/tint/writer/wgsl/generator_impl_diagnostic_test.cc b/src/tint/writer/wgsl/generator_impl_diagnostic_test.cc
index 2a2f4b6..2aeab09 100644
--- a/src/tint/writer/wgsl/generator_impl_diagnostic_test.cc
+++ b/src/tint/writer/wgsl/generator_impl_diagnostic_test.cc
@@ -22,25 +22,25 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_DiagnosticDirective) {
-    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+    DiagnosticDirective(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
 
     GeneratorImpl& gen = Build();
     gen.Generate();
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
-    EXPECT_EQ(gen.result(), R"(diagnostic(error, chromium_unreachable_code);
+    EXPECT_EQ(gen.result(), R"(diagnostic(error, chromium.unreachable_code);
 
 )");
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_DiagnosticAttribute) {
     auto* attr =
-        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium_unreachable_code");
+        DiagnosticAttribute(builtin::DiagnosticSeverity::kError, "chromium", "unreachable_code");
     Func("foo", {}, ty.void_(), {}, utils::Vector{attr});
 
     GeneratorImpl& gen = Build();
     gen.Generate();
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
-    EXPECT_EQ(gen.result(), R"(@diagnostic(error, chromium_unreachable_code)
+    EXPECT_EQ(gen.result(), R"(@diagnostic(error, chromium.unreachable_code)
 fn foo() {
 }
 )");