diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 07c5350..9e39630 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -482,8 +482,11 @@
     "transform/builtin_polyfill.h",
     "transform/calculate_array_length.cc",
     "transform/calculate_array_length.h",
+    "transform/calculate_array_length.h",
     "transform/canonicalize_entry_point_io.cc",
     "transform/canonicalize_entry_point_io.h",
+    "transform/clamp_frag_depth.cc",
+    "transform/clamp_frag_depth.h",
     "transform/combine_samplers.cc",
     "transform/combine_samplers.h",
     "transform/decompose_memory_access.cc",
@@ -574,6 +577,7 @@
     "utils/map.h",
     "utils/math.h",
     "utils/scoped_assignment.h",
+    "utils/string.cc",
     "utils/string.h",
     "utils/unique_allocator.h",
     "utils/unique_vector.h",
@@ -1191,6 +1195,7 @@
       "transform/builtin_polyfill_test.cc",
       "transform/calculate_array_length_test.cc",
       "transform/canonicalize_entry_point_io_test.cc",
+      "transform/clamp_frag_depth_test.cc",
       "transform/combine_samplers_test.cc",
       "transform/decompose_memory_access_test.cc",
       "transform/decompose_strided_array_test.cc",
@@ -1214,6 +1219,7 @@
       "transform/simplify_pointers_test.cc",
       "transform/single_entry_point_test.cc",
       "transform/spirv_atomic_test.cc",
+      "transform/std140_exhaustive_test.cc",
       "transform/std140_test.cc",
       "transform/substitute_override_test.cc",
       "transform/test_helper.h",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 10b0686..c331ccf 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -394,6 +394,8 @@
   transform/builtin_polyfill.h
   transform/calculate_array_length.cc
   transform/calculate_array_length.h
+  transform/clamp_frag_depth.cc
+  transform/clamp_frag_depth.h
   transform/canonicalize_entry_point_io.cc
   transform/canonicalize_entry_point_io.h
   transform/combine_samplers.cc
@@ -484,6 +486,7 @@
   utils/map.h
   utils/math.h
   utils/scoped_assignment.h
+  utils/string.cc
   utils/string.h
   utils/unique_allocator.h
   utils/unique_vector.h
@@ -1105,6 +1108,7 @@
       transform/binding_remapper_test.cc
       transform/builtin_polyfill_test.cc
       transform/calculate_array_length_test.cc
+      transform/clamp_frag_depth_test.cc
       transform/canonicalize_entry_point_io_test.cc
       transform/combine_samplers_test.cc
       transform/decompose_memory_access_test.cc
@@ -1130,6 +1134,7 @@
       transform/simplify_pointers_test.cc
       transform/single_entry_point_test.cc
       transform/spirv_atomic_test.cc
+      transform/std140_exhaustive_test.cc
       transform/std140_test.cc
       transform/substitute_override_test.cc
       transform/test_helper.h
diff --git a/src/tint/ast/access.cc b/src/tint/ast/access.cc
index 642d852..3997715 100644
--- a/src/tint/ast/access.cc
+++ b/src/tint/ast/access.cc
@@ -12,30 +12,46 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/ast/access.cc.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
 #include "src/tint/ast/access.h"
 
 namespace tint::ast {
 
-std::ostream& operator<<(std::ostream& out, Access access) {
-    switch (access) {
-        case ast::Access::kUndefined: {
-            out << "undefined";
-            break;
-        }
-        case ast::Access::kRead: {
-            out << "read";
-            break;
-        }
-        case ast::Access::kReadWrite: {
-            out << "read_write";
-            break;
-        }
-        case ast::Access::kWrite: {
-            out << "write";
-            break;
-        }
+/// ParseAccess parses a Access from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or Access::kInvalid if the string could not be parsed.
+Access ParseAccess(std::string_view str) {
+    if (str == "read") {
+        return Access::kRead;
     }
-    return out;
+    if (str == "read_write") {
+        return Access::kReadWrite;
+    }
+    if (str == "write") {
+        return Access::kWrite;
+    }
+    return Access::kInvalid;
+}
+
+std::ostream& operator<<(std::ostream& out, Access value) {
+    switch (value) {
+        case Access::kInvalid:
+            return out << "invalid";
+        case Access::kRead:
+            return out << "read";
+        case Access::kReadWrite:
+            return out << "read_write";
+        case Access::kWrite:
+            return out << "write";
+    }
+    return out << "<unknown>";
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/access.cc.tmpl b/src/tint/ast/access.cc.tmpl
new file mode 100644
index 0000000..bd52a3b
--- /dev/null
+++ b/src/tint/ast/access.cc.tmpl
@@ -0,0 +1,25 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate access.cc
+
+To update the generated file, run:
+    ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+{{- Import "src/tint/templates/enums.tmpl.inc" -}}
+{{- $enum := (Sem.Enum "access") -}}
+
+#include "src/tint/ast/access.h"
+
+namespace tint::ast {
+
+{{ Eval "ParseEnum" $enum}}
+
+{{ Eval "EnumOStream" $enum}}
+
+}  // namespace tint::ast
diff --git a/src/tint/ast/access.h b/src/tint/ast/access.h
index 3714b70..12e1a20 100644
--- a/src/tint/ast/access.h
+++ b/src/tint/ast/access.h
@@ -12,32 +12,44 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/ast/access.h.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
 #ifndef SRC_TINT_AST_ACCESS_H_
 #define SRC_TINT_AST_ACCESS_H_
 
 #include <ostream>
-#include <string>
 
 namespace tint::ast {
 
-/// The access control settings
-enum Access {
-    /// Not declared in the source
-    kUndefined = 0,
-    /// Read only
+/// Address space of a given pointer.
+enum class Access {
+    kInvalid,
     kRead,
-    /// Write only
-    kWrite,
-    /// Read write
     kReadWrite,
-    // Last valid access mode
-    kLastValid = kReadWrite,
+    kWrite,
 };
 
 /// @param out the std::ostream to write to
-/// @param access the Access
-/// @return the std::ostream so calls can be chained
-std::ostream& operator<<(std::ostream& out, Access access);
+/// @param value the Access
+/// @returns `out` so calls can be chained
+std::ostream& operator<<(std::ostream& out, Access value);
+
+/// ParseAccess parses a Access from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or Access::kInvalid if the string could not be parsed.
+Access ParseAccess(std::string_view str);
+
+constexpr const char* kAccessStrings[] = {
+    "read",
+    "read_write",
+    "write",
+};
 
 }  // namespace tint::ast
 
diff --git a/src/tint/ast/access.h.tmpl b/src/tint/ast/access.h.tmpl
new file mode 100644
index 0000000..ab14fcf
--- /dev/null
+++ b/src/tint/ast/access.h.tmpl
@@ -0,0 +1,29 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate access.h
+
+To update the generated file, run:
+    ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+{{- Import "src/tint/templates/enums.tmpl.inc" -}}
+{{- $enum := (Sem.Enum "access") -}}
+
+#ifndef SRC_TINT_AST_ACCESS_H_
+#define SRC_TINT_AST_ACCESS_H_
+
+#include <ostream>
+
+namespace tint::ast {
+
+/// Address space of a given pointer.
+{{ Eval "DeclareEnum" $enum}}
+
+}  // namespace tint::ast
+
+#endif  // SRC_TINT_AST_ACCESS_H_
diff --git a/src/tint/ast/address_space.cc b/src/tint/ast/address_space.cc
index a55fb87..d8174a2 100644
--- a/src/tint/ast/address_space.cc
+++ b/src/tint/ast/address_space.cc
@@ -34,17 +34,17 @@
     if (str == "private") {
         return AddressSpace::kPrivate;
     }
-    if (str == "workgroup") {
-        return AddressSpace::kWorkgroup;
-    }
-    if (str == "uniform") {
-        return AddressSpace::kUniform;
+    if (str == "push_constant") {
+        return AddressSpace::kPushConstant;
     }
     if (str == "storage") {
         return AddressSpace::kStorage;
     }
-    if (str == "push_constant") {
-        return AddressSpace::kPushConstant;
+    if (str == "uniform") {
+        return AddressSpace::kUniform;
+    }
+    if (str == "workgroup") {
+        return AddressSpace::kWorkgroup;
     }
     return AddressSpace::kInvalid;
 }
@@ -53,26 +53,26 @@
     switch (value) {
         case AddressSpace::kInvalid:
             return out << "invalid";
-        case AddressSpace::kNone:
-            return out << "none";
         case AddressSpace::kFunction:
             return out << "function";
-        case AddressSpace::kPrivate:
-            return out << "private";
-        case AddressSpace::kWorkgroup:
-            return out << "workgroup";
-        case AddressSpace::kUniform:
-            return out << "uniform";
-        case AddressSpace::kStorage:
-            return out << "storage";
-        case AddressSpace::kPushConstant:
-            return out << "push_constant";
         case AddressSpace::kHandle:
             return out << "handle";
         case AddressSpace::kIn:
             return out << "in";
+        case AddressSpace::kNone:
+            return out << "none";
         case AddressSpace::kOut:
             return out << "out";
+        case AddressSpace::kPrivate:
+            return out << "private";
+        case AddressSpace::kPushConstant:
+            return out << "push_constant";
+        case AddressSpace::kStorage:
+            return out << "storage";
+        case AddressSpace::kUniform:
+            return out << "uniform";
+        case AddressSpace::kWorkgroup:
+            return out << "workgroup";
     }
     return out << "<unknown>";
 }
diff --git a/src/tint/ast/address_space.h b/src/tint/ast/address_space.h
index 210dc7f..8b96f0f 100644
--- a/src/tint/ast/address_space.h
+++ b/src/tint/ast/address_space.h
@@ -30,16 +30,16 @@
 /// Address space of a given pointer.
 enum class AddressSpace {
     kInvalid,
-    kNone,  // Tint-internal enum entry - not parsed
     kFunction,
-    kPrivate,
-    kWorkgroup,
-    kUniform,
-    kStorage,
-    kPushConstant,
     kHandle,  // Tint-internal enum entry - not parsed
     kIn,      // Tint-internal enum entry - not parsed
+    kNone,    // Tint-internal enum entry - not parsed
     kOut,     // Tint-internal enum entry - not parsed
+    kPrivate,
+    kPushConstant,
+    kStorage,
+    kUniform,
+    kWorkgroup,
 };
 
 /// @param out the std::ostream to write to
@@ -52,6 +52,10 @@
 /// @returns the parsed enum, or AddressSpace::kInvalid if the string could not be parsed.
 AddressSpace ParseAddressSpace(std::string_view str);
 
+constexpr const char* kAddressSpaceStrings[] = {
+    "function", "private", "push_constant", "storage", "uniform", "workgroup",
+};
+
 /// @returns true if the AddressSpace is host-shareable
 /// @param address_space the AddressSpace
 /// @see https://gpuweb.github.io/gpuweb/wgsl.html#host-shareable
diff --git a/src/tint/ast/address_space_bench.cc b/src/tint/ast/address_space_bench.cc
index 364d015..fb3b0a5 100644
--- a/src/tint/ast/address_space_bench.cc
+++ b/src/tint/ast/address_space_bench.cc
@@ -31,48 +31,15 @@
 
 void AddressSpaceParser(::benchmark::State& state) {
     std::array kStrings{
-        "fccnctin",
-        "ucti3",
-        "functVon",
-        "function",
-        "1unction",
-        "unJtqqon",
-        "llun77tion",
-        "ppqqivtHH",
-        "prcv",
-        "bivaGe",
-        "private",
-        "priviive",
-        "8WWivate",
-        "pxxvate",
-        "wXkgrggup",
-        "worXVup",
-        "3orkgroup",
-        "workgroup",
-        "workgroEp",
-        "woTTPkroup",
-        "ddorkroxxp",
-        "u44iform",
-        "unSSfoVVm",
-        "RniR22m",
-        "uniform",
-        "uFfo9m",
-        "uniorm",
-        "VOORRHrm",
-        "straye",
-        "llntrrr77ge",
-        "stor4g00",
-        "storage",
-        "trooe",
-        "zzrage",
-        "siioppa1",
-        "puXXh_constant",
-        "pusII9_nn55nstant",
-        "YusHH_coaastSSrnt",
-        "push_constant",
-        "pushonkkHan",
-        "jush_consgRt",
-        "puh_cobsant",
+        "fccnctin",       "ucti3",         "functVon",      "function",      "1unction",
+        "unJtqqon",       "llun77tion",    "ppqqivtHH",     "prcv",          "bivaGe",
+        "private",        "priviive",      "8WWivate",      "pxxvate",       "pXh_cggnstant",
+        "pX_Vonstanu",    "push_consta3t", "push_constant", "push_constanE", "push_TTPnstant",
+        "puxxdh_constan", "s44orage",      "stSSraVVe",     "RtoR22e",       "storage",
+        "sFra9e",         "stoage",        "VOORRHge",      "unfoym",        "llnnrrf77rm",
+        "unif4r00",       "uniform",       "nfoom",         "zzform",        "uiiippo1",
+        "workgrouXX",     "wor55gro99nII", "wrrrkgroSSaHH", "workgroup",     "kkrHoup",
+        "jgkrouRR",       "wokroub",
     };
     for (auto _ : state) {
         for (auto& str : kStrings) {
diff --git a/src/tint/ast/address_space_test.cc b/src/tint/ast/address_space_test.cc
index 86a8e40..271cf33 100644
--- a/src/tint/ast/address_space_test.cc
+++ b/src/tint/ast/address_space_test.cc
@@ -42,21 +42,24 @@
 }
 
 static constexpr Case kValidCases[] = {
-    {"function", AddressSpace::kFunction},   {"private", AddressSpace::kPrivate},
-    {"workgroup", AddressSpace::kWorkgroup}, {"uniform", AddressSpace::kUniform},
-    {"storage", AddressSpace::kStorage},     {"push_constant", AddressSpace::kPushConstant},
+    {"function", AddressSpace::kFunction},
+    {"private", AddressSpace::kPrivate},
+    {"push_constant", AddressSpace::kPushConstant},
+    {"storage", AddressSpace::kStorage},
+    {"uniform", AddressSpace::kUniform},
+    {"workgroup", AddressSpace::kWorkgroup},
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"fccnctin", AddressSpace::kInvalid},       {"ucti3", AddressSpace::kInvalid},
-    {"functVon", AddressSpace::kInvalid},       {"priv1te", AddressSpace::kInvalid},
-    {"pqiJate", AddressSpace::kInvalid},        {"privat7ll", AddressSpace::kInvalid},
-    {"workroppqHH", AddressSpace::kInvalid},    {"workru", AddressSpace::kInvalid},
-    {"wbkgGoup", AddressSpace::kInvalid},       {"unifiivm", AddressSpace::kInvalid},
-    {"8WWiform", AddressSpace::kInvalid},       {"uxxform", AddressSpace::kInvalid},
-    {"sXraggg", AddressSpace::kInvalid},        {"traXe", AddressSpace::kInvalid},
-    {"stor3ge", AddressSpace::kInvalid},        {"push_constanE", AddressSpace::kInvalid},
-    {"push_TTPnstant", AddressSpace::kInvalid}, {"puxxdh_constan", AddressSpace::kInvalid},
+    {"fccnctin", AddressSpace::kInvalid},        {"ucti3", AddressSpace::kInvalid},
+    {"functVon", AddressSpace::kInvalid},        {"priv1te", AddressSpace::kInvalid},
+    {"pqiJate", AddressSpace::kInvalid},         {"privat7ll", AddressSpace::kInvalid},
+    {"pqqsh_pponstHnt", AddressSpace::kInvalid}, {"pus_cnstat", AddressSpace::kInvalid},
+    {"bus_Gonstant", AddressSpace::kInvalid},    {"storiive", AddressSpace::kInvalid},
+    {"8WWorage", AddressSpace::kInvalid},        {"sxxrage", AddressSpace::kInvalid},
+    {"uXforgg", AddressSpace::kInvalid},         {"nfoXm", AddressSpace::kInvalid},
+    {"unif3rm", AddressSpace::kInvalid},         {"workgroEp", AddressSpace::kInvalid},
+    {"woTTPkroup", AddressSpace::kInvalid},      {"ddorkroxxp", AddressSpace::kInvalid},
 };
 
 using AddressSpaceParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/ast/builtin_value.cc b/src/tint/ast/builtin_value.cc
index e8d6451..d4eaec0 100644
--- a/src/tint/ast/builtin_value.cc
+++ b/src/tint/ast/builtin_value.cc
@@ -28,20 +28,17 @@
 /// @param str the string to parse
 /// @returns the parsed enum, or BuiltinValue::kInvalid if the string could not be parsed.
 BuiltinValue ParseBuiltinValue(std::string_view str) {
-    if (str == "position") {
-        return BuiltinValue::kPosition;
-    }
-    if (str == "vertex_index") {
-        return BuiltinValue::kVertexIndex;
-    }
-    if (str == "instance_index") {
-        return BuiltinValue::kInstanceIndex;
+    if (str == "frag_depth") {
+        return BuiltinValue::kFragDepth;
     }
     if (str == "front_facing") {
         return BuiltinValue::kFrontFacing;
     }
-    if (str == "frag_depth") {
-        return BuiltinValue::kFragDepth;
+    if (str == "global_invocation_id") {
+        return BuiltinValue::kGlobalInvocationId;
+    }
+    if (str == "instance_index") {
+        return BuiltinValue::kInstanceIndex;
     }
     if (str == "local_invocation_id") {
         return BuiltinValue::kLocalInvocationId;
@@ -49,21 +46,24 @@
     if (str == "local_invocation_index") {
         return BuiltinValue::kLocalInvocationIndex;
     }
-    if (str == "global_invocation_id") {
-        return BuiltinValue::kGlobalInvocationId;
-    }
-    if (str == "workgroup_id") {
-        return BuiltinValue::kWorkgroupId;
-    }
     if (str == "num_workgroups") {
         return BuiltinValue::kNumWorkgroups;
     }
+    if (str == "position") {
+        return BuiltinValue::kPosition;
+    }
     if (str == "sample_index") {
         return BuiltinValue::kSampleIndex;
     }
     if (str == "sample_mask") {
         return BuiltinValue::kSampleMask;
     }
+    if (str == "vertex_index") {
+        return BuiltinValue::kVertexIndex;
+    }
+    if (str == "workgroup_id") {
+        return BuiltinValue::kWorkgroupId;
+    }
     return BuiltinValue::kInvalid;
 }
 
@@ -71,32 +71,32 @@
     switch (value) {
         case BuiltinValue::kInvalid:
             return out << "invalid";
-        case BuiltinValue::kPosition:
-            return out << "position";
-        case BuiltinValue::kVertexIndex:
-            return out << "vertex_index";
-        case BuiltinValue::kInstanceIndex:
-            return out << "instance_index";
-        case BuiltinValue::kFrontFacing:
-            return out << "front_facing";
         case BuiltinValue::kFragDepth:
             return out << "frag_depth";
+        case BuiltinValue::kFrontFacing:
+            return out << "front_facing";
+        case BuiltinValue::kGlobalInvocationId:
+            return out << "global_invocation_id";
+        case BuiltinValue::kInstanceIndex:
+            return out << "instance_index";
         case BuiltinValue::kLocalInvocationId:
             return out << "local_invocation_id";
         case BuiltinValue::kLocalInvocationIndex:
             return out << "local_invocation_index";
-        case BuiltinValue::kGlobalInvocationId:
-            return out << "global_invocation_id";
-        case BuiltinValue::kWorkgroupId:
-            return out << "workgroup_id";
         case BuiltinValue::kNumWorkgroups:
             return out << "num_workgroups";
+        case BuiltinValue::kPointSize:
+            return out << "point_size";
+        case BuiltinValue::kPosition:
+            return out << "position";
         case BuiltinValue::kSampleIndex:
             return out << "sample_index";
         case BuiltinValue::kSampleMask:
             return out << "sample_mask";
-        case BuiltinValue::kPointSize:
-            return out << "point_size";
+        case BuiltinValue::kVertexIndex:
+            return out << "vertex_index";
+        case BuiltinValue::kWorkgroupId:
+            return out << "workgroup_id";
     }
     return out << "<unknown>";
 }
diff --git a/src/tint/ast/builtin_value.h b/src/tint/ast/builtin_value.h
index 0a2c7f0..f7dd660 100644
--- a/src/tint/ast/builtin_value.h
+++ b/src/tint/ast/builtin_value.h
@@ -27,22 +27,22 @@
 
 namespace tint::ast {
 
-/// Storage class of a given pointer.
+/// Builtin value defined with `@builtin(<name>)`.
 enum class BuiltinValue {
     kInvalid,
-    kPosition,
-    kVertexIndex,
-    kInstanceIndex,
-    kFrontFacing,
     kFragDepth,
+    kFrontFacing,
+    kGlobalInvocationId,
+    kInstanceIndex,
     kLocalInvocationId,
     kLocalInvocationIndex,
-    kGlobalInvocationId,
-    kWorkgroupId,
     kNumWorkgroups,
+    kPointSize,  // Tint-internal enum entry - not parsed
+    kPosition,
     kSampleIndex,
     kSampleMask,
-    kPointSize,  // Tint-internal enum entry - not parsed
+    kVertexIndex,
+    kWorkgroupId,
 };
 
 /// @param out the std::ostream to write to
@@ -55,6 +55,15 @@
 /// @returns the parsed enum, or BuiltinValue::kInvalid if the string could not be parsed.
 BuiltinValue ParseBuiltinValue(std::string_view str);
 
+constexpr const char* kBuiltinValueStrings[] = {
+    "frag_depth",           "front_facing",
+    "global_invocation_id", "instance_index",
+    "local_invocation_id",  "local_invocation_index",
+    "num_workgroups",       "position",
+    "sample_index",         "sample_mask",
+    "vertex_index",         "workgroup_id",
+};
+
 }  // namespace tint::ast
 
 #endif  // SRC_TINT_AST_BUILTIN_VALUE_H_
diff --git a/src/tint/ast/builtin_value.h.tmpl b/src/tint/ast/builtin_value.h.tmpl
index 1985305..ea63d56 100644
--- a/src/tint/ast/builtin_value.h.tmpl
+++ b/src/tint/ast/builtin_value.h.tmpl
@@ -18,7 +18,7 @@
 
 namespace tint::ast {
 
-/// Storage class of a given pointer.
+/// Builtin value defined with `@builtin(<name>)`.
 {{ Eval "DeclareEnum" $enum}}
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/builtin_value_bench.cc b/src/tint/ast/builtin_value_bench.cc
index 0a4048c..b323b6b 100644
--- a/src/tint/ast/builtin_value_bench.cc
+++ b/src/tint/ast/builtin_value_bench.cc
@@ -31,90 +31,90 @@
 
 void BuiltinValueParser(::benchmark::State& state) {
     std::array kStrings{
-        "pccsitin",
-        "oiti3",
-        "positVon",
-        "position",
-        "1osition",
-        "osJtqqon",
-        "llos77tion",
-        "vrtHHppx_index",
-        "vertx_icx",
-        "veGtex_bnde",
-        "vertex_index",
-        "vertex_inveii",
-        "veWWtex_ind8x",
-        "vxxrtMx_indx",
-        "isXance_indegg",
-        "insanc_iXVex",
-        "instance_in3ex",
-        "instance_index",
-        "instancE_index",
-        "nsTTance_PPndex",
-        "nstancxx_indddx",
-        "44ront_facing",
-        "fSSont_facinVV",
-        "fronR_Racing",
-        "front_facing",
-        "ron9_faciFg",
-        "front_facin",
-        "fVonRR_HaOing",
-        "fyag_epth",
-        "f77ag_nnellrrh",
-        "fra400depth",
+        "fragdeccth",
+        "flaget3",
+        "fVag_depth",
         "frag_depth",
-        "fa_epooh",
-        "frg_ezzth",
-        "f11a_eppiih",
-        "local_invXXcation_id",
-        "lIIcal_i5599ocation_inn",
-        "HHrrcal_inSSocation_Yaa",
-        "local_invocation_id",
-        "lokkal_invocatini",
-        "jocal_invocRRongid",
-        "local_inocatbon_i",
-        "local_injocation_index",
-        "local_invocatio_index",
-        "locl_invocqtion_ndex",
-        "local_invocation_index",
-        "localNNinvocaton_index",
-        "local_invocatin_ivvdx",
-        "locl_invocatioQQ_index",
-        "globalrnvocaton_iff",
-        "global_invocation_jd",
-        "NNlbal_wwnvocation82d",
+        "frag1depth",
+        "fraJqqepth",
+        "fra7ll_depth",
+        "fonHHpp_facing",
+        "fron_facg",
+        "frGnt_fbcin",
+        "front_facing",
+        "front_facvnii",
+        "frWWnt_faci8g",
+        "fxxonM_facig",
+        "gXobalgginvocationid",
+        "goVal_uvocatioX_id",
+        "global_in3ocation_id",
         "global_invocation_id",
-        "global_invocationid",
-        "globalrrinvocation_id",
-        "globaG_invocation_id",
-        "workgroupFFid",
-        "worgrupid",
-        "workgroup_rr",
-        "workgroup_id",
-        "workgrouid",
-        "DokgXoJJp_id",
-        "8orgrup_i",
-        "num_wkkr11up",
-        "numworkgroups",
-        "Ju_workgroups",
+        "global_invocation_iE",
+        "TTobal_invocationPPid",
+        "globdd_invocatioxx_id",
+        "instance44index",
+        "instaVVce_SSndex",
+        "Rnstane_ind2Rx",
+        "instance_index",
+        "inFtanceind9x",
+        "insance_index",
+        "inRRancV_OOHdex",
+        "local_nvocytion_id",
+        "llGcnnl_inv77catirrn_id",
+        "local_invoca4i00n_id",
+        "local_invocation_id",
+        "loool_nvocaton_id",
+        "local_inozztion_id",
+        "p11cal_invocatiiin_i",
+        "local_invocation_iXXdex",
+        "local_invnnIIati99n55index",
+        "localYirrHHocaationSSindex",
+        "local_invocation_index",
+        "lkkal_invHcation_idx",
+        "gRcal_invocatioj_inex",
+        "lcal_invcbtion_index",
+        "num_workgroujs",
+        "num_worgroups",
+        "nuq_orkgoups",
         "num_workgroups",
-        "num_corkgroups",
-        "num_woOkgroups",
-        "num_workKK__vvttps",
-        "smple5inxxe8",
-        "s__mle_qFdex",
-        "saqqple_idex",
+        "nm_workgroNNps",
+        "um_workgrovps",
+        "nQQm_orkgroups",
+        "posftrn",
+        "pojition",
+        "poswNN82n",
+        "position",
+        "positon",
+        "porrition",
+        "pGsition",
+        "sample_inFFex",
+        "samleinex",
+        "sample_indrr",
         "sample_index",
-        "saOpe_33nde66",
-        "s6oople_indttQx",
-        "sam66le_inex",
-        "samxe66masOz",
-        "yyample_mask",
-        "amplZZHask",
+        "sample_iex",
+        "DaplX_JJndex",
+        "8amleinde",
+        "saplekmak",
+        "samle_mask",
+        "saJple_mak",
         "sample_mask",
-        "WWaple_maq4k",
-        "samplOO_ask",
-        "sYohpe_msk",
+        "sample_cask",
+        "sample_maOk",
+        "__attpvve_KKask",
+        "vrtex5inxxe8",
+        "v__rex_qFdex",
+        "veqqtex_idex",
+        "vertex_index",
+        "veOtx_33nde66",
+        "v6ootex_indttQx",
+        "ver66ex_inex",
+        "worzzroup6Oxd",
+        "workgroyyp_id",
+        "wokrHHZpZid",
+        "workgroup_id",
+        "wWWkgqoup44id",
+        "wrkgroOOp_id",
+        "hrkgYooup_d",
     };
     for (auto _ : state) {
         for (auto& str : kStrings) {
diff --git a/src/tint/ast/builtin_value_test.cc b/src/tint/ast/builtin_value_test.cc
index a29810a..55f8e4d 100644
--- a/src/tint/ast/builtin_value_test.cc
+++ b/src/tint/ast/builtin_value_test.cc
@@ -42,57 +42,57 @@
 }
 
 static constexpr Case kValidCases[] = {
-    {"position", BuiltinValue::kPosition},
-    {"vertex_index", BuiltinValue::kVertexIndex},
-    {"instance_index", BuiltinValue::kInstanceIndex},
-    {"front_facing", BuiltinValue::kFrontFacing},
     {"frag_depth", BuiltinValue::kFragDepth},
+    {"front_facing", BuiltinValue::kFrontFacing},
+    {"global_invocation_id", BuiltinValue::kGlobalInvocationId},
+    {"instance_index", BuiltinValue::kInstanceIndex},
     {"local_invocation_id", BuiltinValue::kLocalInvocationId},
     {"local_invocation_index", BuiltinValue::kLocalInvocationIndex},
-    {"global_invocation_id", BuiltinValue::kGlobalInvocationId},
-    {"workgroup_id", BuiltinValue::kWorkgroupId},
     {"num_workgroups", BuiltinValue::kNumWorkgroups},
+    {"position", BuiltinValue::kPosition},
     {"sample_index", BuiltinValue::kSampleIndex},
     {"sample_mask", BuiltinValue::kSampleMask},
+    {"vertex_index", BuiltinValue::kVertexIndex},
+    {"workgroup_id", BuiltinValue::kWorkgroupId},
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"pccsitin", BuiltinValue::kInvalid},
-    {"oiti3", BuiltinValue::kInvalid},
-    {"positVon", BuiltinValue::kInvalid},
-    {"1ertex_index", BuiltinValue::kInvalid},
-    {"vertex_Jnqex", BuiltinValue::kInvalid},
-    {"velltex_inde77", BuiltinValue::kInvalid},
-    {"inpptanceqHHindx", BuiltinValue::kInvalid},
-    {"cnsanvendex", BuiltinValue::kInvalid},
-    {"istancG_index", BuiltinValue::kInvalid},
-    {"front_facvnii", BuiltinValue::kInvalid},
-    {"frWWnt_faci8g", BuiltinValue::kInvalid},
-    {"fxxonM_facig", BuiltinValue::kInvalid},
-    {"fXag_detgg", BuiltinValue::kInvalid},
-    {"fag_XuVh", BuiltinValue::kInvalid},
-    {"frag_dept3", BuiltinValue::kInvalid},
-    {"local_Envocation_id", BuiltinValue::kInvalid},
-    {"localiPPvocatioTT_id", BuiltinValue::kInvalid},
-    {"localxxnvocationddid", BuiltinValue::kInvalid},
-    {"loca44_invocation_index", BuiltinValue::kInvalid},
-    {"local_invocSStionVVindex", BuiltinValue::kInvalid},
-    {"locRR_invocat22n_index", BuiltinValue::kInvalid},
-    {"globalFinvoction_id", BuiltinValue::kInvalid},
-    {"gloal_invocation_id", BuiltinValue::kInvalid},
-    {"RRlHOOaV_invoction_id", BuiltinValue::kInvalid},
-    {"workgyoup_i", BuiltinValue::kInvalid},
-    {"wnrrrkg77loup_Gd", BuiltinValue::kInvalid},
-    {"00orkgr4up_id", BuiltinValue::kInvalid},
-    {"numwroogrops", BuiltinValue::kInvalid},
-    {"nzm_wokgroups", BuiltinValue::kInvalid},
-    {"uippworkgro11ps", BuiltinValue::kInvalid},
-    {"sample_iXXdex", BuiltinValue::kInvalid},
-    {"5nnample_99IIdex", BuiltinValue::kInvalid},
-    {"samYlaaHHrrndeSS", BuiltinValue::kInvalid},
-    {"aHkk_mask", BuiltinValue::kInvalid},
-    {"jRRmpl_gsk", BuiltinValue::kInvalid},
-    {"smple_mbk", BuiltinValue::kInvalid},
+    {"fragdeccth", BuiltinValue::kInvalid},
+    {"flaget3", BuiltinValue::kInvalid},
+    {"fVag_depth", BuiltinValue::kInvalid},
+    {"1ront_facing", BuiltinValue::kInvalid},
+    {"front_fJcqng", BuiltinValue::kInvalid},
+    {"frllnt_facin77", BuiltinValue::kInvalid},
+    {"global_invoqqtionppHid", BuiltinValue::kInvalid},
+    {"clvbal_inocaionid", BuiltinValue::kInvalid},
+    {"global_Gvocation_id", BuiltinValue::kInvalid},
+    {"invtance_iniiex", BuiltinValue::kInvalid},
+    {"8nstanceWWindex", BuiltinValue::kInvalid},
+    {"insxxanceindex", BuiltinValue::kInvalid},
+    {"lXcal_invoation_igg", BuiltinValue::kInvalid},
+    {"Xocal_nvocatin_Vd", BuiltinValue::kInvalid},
+    {"local_invoca3ion_id", BuiltinValue::kInvalid},
+    {"local_invocation_indeE", BuiltinValue::kInvalid},
+    {"loTTal_invPPcatin_index", BuiltinValue::kInvalid},
+    {"loal_invocadxxion_index", BuiltinValue::kInvalid},
+    {"num_work44roups", BuiltinValue::kInvalid},
+    {"num_wVVrkgSSoups", BuiltinValue::kInvalid},
+    {"Rum_wokgrou2Rs", BuiltinValue::kInvalid},
+    {"oFi9ion", BuiltinValue::kInvalid},
+    {"postion", BuiltinValue::kInvalid},
+    {"ROOoHiiVn", BuiltinValue::kInvalid},
+    {"samply_inde", BuiltinValue::kInvalid},
+    {"snrrmpl77l_indGx", BuiltinValue::kInvalid},
+    {"00ample4index", BuiltinValue::kInvalid},
+    {"smoo_mask", BuiltinValue::kInvalid},
+    {"sampzemask", BuiltinValue::kInvalid},
+    {"ppaplii1_mas", BuiltinValue::kInvalid},
+    {"vertex_iXXdex", BuiltinValue::kInvalid},
+    {"5nnertex_99IIdex", BuiltinValue::kInvalid},
+    {"verYeaaHHrrndeSS", BuiltinValue::kInvalid},
+    {"workkgHo_i", BuiltinValue::kInvalid},
+    {"worRgoupjid", BuiltinValue::kInvalid},
+    {"wrkgrupbid", BuiltinValue::kInvalid},
 };
 
 using BuiltinValueParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/ast/extension.cc b/src/tint/ast/extension.cc
index e57b248..a4d823f 100644
--- a/src/tint/ast/extension.cc
+++ b/src/tint/ast/extension.cc
@@ -28,18 +28,18 @@
 /// @param str the string to parse
 /// @returns the parsed enum, or Extension::kInvalid if the string could not be parsed.
 Extension ParseExtension(std::string_view str) {
-    if (str == "f16") {
-        return Extension::kF16;
+    if (str == "chromium_disable_uniformity_analysis") {
+        return Extension::kChromiumDisableUniformityAnalysis;
     }
     if (str == "chromium_experimental_dp4a") {
         return Extension::kChromiumExperimentalDp4A;
     }
-    if (str == "chromium_disable_uniformity_analysis") {
-        return Extension::kChromiumDisableUniformityAnalysis;
-    }
     if (str == "chromium_experimental_push_constant") {
         return Extension::kChromiumExperimentalPushConstant;
     }
+    if (str == "f16") {
+        return Extension::kF16;
+    }
     return Extension::kInvalid;
 }
 
@@ -47,14 +47,14 @@
     switch (value) {
         case Extension::kInvalid:
             return out << "invalid";
-        case Extension::kF16:
-            return out << "f16";
-        case Extension::kChromiumExperimentalDp4A:
-            return out << "chromium_experimental_dp4a";
         case Extension::kChromiumDisableUniformityAnalysis:
             return out << "chromium_disable_uniformity_analysis";
+        case Extension::kChromiumExperimentalDp4A:
+            return out << "chromium_experimental_dp4a";
         case Extension::kChromiumExperimentalPushConstant:
             return out << "chromium_experimental_push_constant";
+        case Extension::kF16:
+            return out << "f16";
     }
     return out << "<unknown>";
 }
diff --git a/src/tint/ast/extension.h b/src/tint/ast/extension.h
index eea9bec..4d1a937 100644
--- a/src/tint/ast/extension.h
+++ b/src/tint/ast/extension.h
@@ -33,10 +33,10 @@
 /// @see src/tint/intrinsics.def for extension descriptions
 enum class Extension {
     kInvalid,
-    kF16,
-    kChromiumExperimentalDp4A,
     kChromiumDisableUniformityAnalysis,
+    kChromiumExperimentalDp4A,
     kChromiumExperimentalPushConstant,
+    kF16,
 };
 
 /// @param out the std::ostream to write to
@@ -49,6 +49,13 @@
 /// @returns the parsed enum, or Extension::kInvalid if the string could not be parsed.
 Extension ParseExtension(std::string_view str);
 
+constexpr const char* kExtensionStrings[] = {
+    "chromium_disable_uniformity_analysis",
+    "chromium_experimental_dp4a",
+    "chromium_experimental_push_constant",
+    "f16",
+};
+
 // A unique vector of extensions
 using Extensions = utils::UniqueVector<Extension, 4>;
 
diff --git a/src/tint/ast/extension_bench.cc b/src/tint/ast/extension_bench.cc
index 8fc9d1c..94b5216 100644
--- a/src/tint/ast/extension_bench.cc
+++ b/src/tint/ast/extension_bench.cc
@@ -31,13 +31,13 @@
 
 void ExtensionParser(::benchmark::State& state) {
     std::array kStrings{
-        "cc6",
-        "s",
-        "HH6",
-        "f16",
-        "116",
-        "qJ6",
-        "f17ll",
+        "chromium_disableuniformiccy_analysis",
+        "chromil3_disable_unifority_analss",
+        "chromium_disable_Vniformity_analysis",
+        "chromium_disable_uniformity_analysis",
+        "chromium_dis1ble_uniformity_analysis",
+        "chromium_qqisable_unifomity_anaJysis",
+        "chrollium_disable_uniformity_analysi77",
         "chromippHm_experqqmetal_dp4a",
         "chrmium_expecimntal_dp4",
         "chrmiumGexpebimental_dp4a",
@@ -45,20 +45,20 @@
         "chromium_exverimentiil_dp4a",
         "chro8ium_experimenWWal_dp4a",
         "chromiMm_eperimxxntal_dp4a",
-        "chXggmium_disable_uniformity_aalysis",
-        "Xhomiuu_disale_uniformity_analysis",
-        "chromium_3isable_uniformity_analysis",
-        "chromium_disable_uniformity_analysis",
-        "chromiuE_disable_uniformity_analysis",
-        "chromium_disable_uniTTormity_aPPalsis",
-        "ddhromium_disabexxuniformity_analysis",
-        "c44romium_experimental_push_constant",
-        "chromium_experimental_pSSsVV_constant",
-        "chrom22Rm_experimental_pushRonstant",
+        "chrXmium_experimeggtal_ush_constant",
+        "chromiu_experVmentalpusX_constant",
+        "chro3ium_experimental_push_constant",
         "chromium_experimental_push_constant",
-        "chromium_exp9rimFntal_ush_constant",
-        "chrmium_experimental_push_constant",
-        "cOOromium_experiVeHtal_puh_conRRtant",
+        "chromium_experEmental_push_constant",
+        "chPPomiumexperimental_push_conTTtant",
+        "chromixxm_experimentddl_push_constnt",
+        "4416",
+        "fSVV6",
+        "RR2",
+        "f16",
+        "96",
+        "f1",
+        "VOR6",
     };
     for (auto _ : state) {
         for (auto& str : kStrings) {
diff --git a/src/tint/ast/extension_test.cc b/src/tint/ast/extension_test.cc
index 283088d..e43266c 100644
--- a/src/tint/ast/extension_test.cc
+++ b/src/tint/ast/extension_test.cc
@@ -42,25 +42,25 @@
 }
 
 static constexpr Case kValidCases[] = {
-    {"f16", Extension::kF16},
-    {"chromium_experimental_dp4a", Extension::kChromiumExperimentalDp4A},
     {"chromium_disable_uniformity_analysis", Extension::kChromiumDisableUniformityAnalysis},
+    {"chromium_experimental_dp4a", Extension::kChromiumExperimentalDp4A},
     {"chromium_experimental_push_constant", Extension::kChromiumExperimentalPushConstant},
+    {"f16", Extension::kF16},
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"cc6", Extension::kInvalid},
-    {"s", Extension::kInvalid},
-    {"HH6", Extension::kInvalid},
+    {"chromium_disableuniformiccy_analysis", Extension::kInvalid},
+    {"chromil3_disable_unifority_analss", Extension::kInvalid},
+    {"chromium_disable_Vniformity_analysis", Extension::kInvalid},
     {"chro1ium_experimental_dp4a", Extension::kInvalid},
     {"chrJmium_experiqqetal_dp4a", Extension::kInvalid},
     {"chromium_experimenll77l_dp4a", Extension::kInvalid},
-    {"chromiumppdisableqquniformity_aalysHHs", Extension::kInvalid},
-    {"chromiu_disable_unifovmitc_analyi", Extension::kInvalid},
-    {"chromium_diable_uGbformity_analysis", Extension::kInvalid},
-    {"chvomium_experimental_push_constiint", Extension::kInvalid},
-    {"chromiu8WWexperimental_push_constant", Extension::kInvalid},
-    {"chromium_experiMental_push_costanxx", Extension::kInvalid},
+    {"cppromium_experiHHenal_qqush_constant", Extension::kInvalid},
+    {"chromium_xpericental_sh_vonstant", Extension::kInvalid},
+    {"chromium_experimental_Gsh_cbnstant", Extension::kInvalid},
+    {"f1vi", Extension::kInvalid},
+    {"f8WW", Extension::kInvalid},
+    {"fxx", Extension::kInvalid},
 };
 
 using ExtensionParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/ast/if_statement.h b/src/tint/ast/if_statement.h
index 81d9756..1c1abc3 100644
--- a/src/tint/ast/if_statement.h
+++ b/src/tint/ast/if_statement.h
@@ -55,7 +55,7 @@
     const BlockStatement* const body;
 
     /// The optional else statement, or nullptr
-    const Statement* else_statement;
+    const Statement* const else_statement;
 };
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/interpolate_attribute.cc b/src/tint/ast/interpolate_attribute.cc
index 29e3bfe..7c89ee1 100644
--- a/src/tint/ast/interpolate_attribute.cc
+++ b/src/tint/ast/interpolate_attribute.cc
@@ -12,6 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/ast/interpolate_attribute.cc.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
 #include "src/tint/ast/interpolate_attribute.h"
 
 #include <string>
@@ -41,44 +49,64 @@
     return ctx->dst->create<InterpolateAttribute>(src, type, sampling);
 }
 
-std::ostream& operator<<(std::ostream& out, InterpolationType type) {
-    switch (type) {
-        case InterpolationType::kPerspective: {
-            out << "perspective";
-            break;
-        }
-        case InterpolationType::kLinear: {
-            out << "linear";
-            break;
-        }
-        case InterpolationType::kFlat: {
-            out << "flat";
-            break;
-        }
+/// ParseInterpolationType parses a InterpolationType from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or InterpolationType::kInvalid if the string could not be parsed.
+InterpolationType ParseInterpolationType(std::string_view str) {
+    if (str == "flat") {
+        return InterpolationType::kFlat;
     }
-    return out;
+    if (str == "linear") {
+        return InterpolationType::kLinear;
+    }
+    if (str == "perspective") {
+        return InterpolationType::kPerspective;
+    }
+    return InterpolationType::kInvalid;
 }
 
-std::ostream& operator<<(std::ostream& out, InterpolationSampling sampling) {
-    switch (sampling) {
-        case InterpolationSampling::kNone: {
-            out << "none";
-            break;
-        }
-        case InterpolationSampling::kCenter: {
-            out << "center";
-            break;
-        }
-        case InterpolationSampling::kCentroid: {
-            out << "centroid";
-            break;
-        }
-        case InterpolationSampling::kSample: {
-            out << "sample";
-            break;
-        }
+std::ostream& operator<<(std::ostream& out, InterpolationType value) {
+    switch (value) {
+        case InterpolationType::kInvalid:
+            return out << "invalid";
+        case InterpolationType::kFlat:
+            return out << "flat";
+        case InterpolationType::kLinear:
+            return out << "linear";
+        case InterpolationType::kPerspective:
+            return out << "perspective";
     }
-    return out;
+    return out << "<unknown>";
+}
+
+/// ParseInterpolationSampling parses a InterpolationSampling from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or InterpolationSampling::kInvalid if the string could not be parsed.
+InterpolationSampling ParseInterpolationSampling(std::string_view str) {
+    if (str == "center") {
+        return InterpolationSampling::kCenter;
+    }
+    if (str == "centroid") {
+        return InterpolationSampling::kCentroid;
+    }
+    if (str == "sample") {
+        return InterpolationSampling::kSample;
+    }
+    return InterpolationSampling::kInvalid;
+}
+
+std::ostream& operator<<(std::ostream& out, InterpolationSampling value) {
+    switch (value) {
+        case InterpolationSampling::kInvalid:
+            return out << "invalid";
+        case InterpolationSampling::kCenter:
+            return out << "center";
+        case InterpolationSampling::kCentroid:
+            return out << "centroid";
+        case InterpolationSampling::kSample:
+            return out << "sample";
+    }
+    return out << "<unknown>";
 }
 
 }  // namespace tint::ast
diff --git a/src/tint/ast/interpolate_attribute.cc.tmpl b/src/tint/ast/interpolate_attribute.cc.tmpl
new file mode 100644
index 0000000..b6f0b35
--- /dev/null
+++ b/src/tint/ast/interpolate_attribute.cc.tmpl
@@ -0,0 +1,50 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate builtin_value.cc
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+{{- Import "src/tint/templates/enums.tmpl.inc" -}}
+
+#include "src/tint/ast/interpolate_attribute.h"
+
+#include <string>
+
+#include "src/tint/program_builder.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ast::InterpolateAttribute);
+
+namespace tint::ast {
+
+InterpolateAttribute::InterpolateAttribute(ProgramID pid,
+                                           NodeID nid,
+                                           const Source& src,
+                                           InterpolationType ty,
+                                           InterpolationSampling smpl)
+    : Base(pid, nid, src), type(ty), sampling(smpl) {}
+
+InterpolateAttribute::~InterpolateAttribute() = default;
+
+std::string InterpolateAttribute::Name() const {
+    return "interpolate";
+}
+
+const InterpolateAttribute* InterpolateAttribute::Clone(CloneContext* ctx) const {
+    // Clone arguments outside of create() call to have deterministic ordering
+    auto src = ctx->Clone(source);
+    return ctx->dst->create<InterpolateAttribute>(src, type, sampling);
+}
+
+{{ Eval "ParseEnum" (Sem.Enum "interpolation_type")}}
+
+{{ Eval "EnumOStream" (Sem.Enum "interpolation_type")}}
+
+{{ Eval "ParseEnum" (Sem.Enum "interpolation_sampling")}}
+
+{{ Eval "EnumOStream" (Sem.Enum "interpolation_sampling")}}
+
+}  // namespace tint::ast
diff --git a/src/tint/ast/interpolate_attribute.h b/src/tint/ast/interpolate_attribute.h
index 4f9ea9d..c6b4af0 100644
--- a/src/tint/ast/interpolate_attribute.h
+++ b/src/tint/ast/interpolate_attribute.h
@@ -1,4 +1,4 @@
-// Copyright 2021 The Tint Authors.
+// Copyright 2022 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,6 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+////////////////////////////////////////////////////////////////////////////////
+// File generated by tools/src/cmd/gen
+// using the template:
+//   src/tint/ast/interpolate_attribute.h.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
 #ifndef SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
 #define SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
 
@@ -23,10 +31,52 @@
 namespace tint::ast {
 
 /// The interpolation type.
-enum class InterpolationType { kPerspective, kLinear, kFlat };
+enum class InterpolationType {
+    kInvalid,
+    kFlat,
+    kLinear,
+    kPerspective,
+};
+
+/// @param out the std::ostream to write to
+/// @param value the InterpolationType
+/// @returns `out` so calls can be chained
+std::ostream& operator<<(std::ostream& out, InterpolationType value);
+
+/// ParseInterpolationType parses a InterpolationType from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or InterpolationType::kInvalid if the string could not be parsed.
+InterpolationType ParseInterpolationType(std::string_view str);
+
+constexpr const char* kInterpolationTypeStrings[] = {
+    "flat",
+    "linear",
+    "perspective",
+};
 
 /// The interpolation sampling.
-enum class InterpolationSampling { kNone = -1, kCenter, kCentroid, kSample };
+enum class InterpolationSampling {
+    kInvalid,
+    kCenter,
+    kCentroid,
+    kSample,
+};
+
+/// @param out the std::ostream to write to
+/// @param value the InterpolationSampling
+/// @returns `out` so calls can be chained
+std::ostream& operator<<(std::ostream& out, InterpolationSampling value);
+
+/// ParseInterpolationSampling parses a InterpolationSampling from a string.
+/// @param str the string to parse
+/// @returns the parsed enum, or InterpolationSampling::kInvalid if the string could not be parsed.
+InterpolationSampling ParseInterpolationSampling(std::string_view str);
+
+constexpr const char* kInterpolationSamplingStrings[] = {
+    "center",
+    "centroid",
+    "sample",
+};
 
 /// An interpolate attribute
 class InterpolateAttribute final : public Castable<InterpolateAttribute, Attribute> {
@@ -60,16 +110,6 @@
     const InterpolationSampling sampling;
 };
 
-/// @param out the std::ostream to write to
-/// @param type the interpolation type
-/// @return the std::ostream so calls can be chained
-std::ostream& operator<<(std::ostream& out, InterpolationType type);
-
-/// @param out the std::ostream to write to
-/// @param sampling the interpolation sampling
-/// @return the std::ostream so calls can be chained
-std::ostream& operator<<(std::ostream& out, InterpolationSampling sampling);
-
 }  // namespace tint::ast
 
 #endif  // SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
diff --git a/src/tint/ast/interpolate_attribute.h.tmpl b/src/tint/ast/interpolate_attribute.h.tmpl
new file mode 100644
index 0000000..c225cb6
--- /dev/null
+++ b/src/tint/ast/interpolate_attribute.h.tmpl
@@ -0,0 +1,63 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate interpolate_attribute.h
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+{{- Import "src/tint/templates/enums.tmpl.inc" -}}
+
+#ifndef SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
+#define SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
+
+#include <ostream>
+#include <string>
+
+#include "src/tint/ast/attribute.h"
+
+namespace tint::ast {
+
+/// The interpolation type.
+{{ Eval "DeclareEnum" (Sem.Enum "interpolation_type") }}
+
+/// The interpolation sampling.
+{{ Eval "DeclareEnum" (Sem.Enum "interpolation_sampling") }}
+
+/// An interpolate attribute
+class InterpolateAttribute final : public Castable<InterpolateAttribute, Attribute> {
+  public:
+    /// Create an interpolate attribute.
+    /// @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 type the interpolation type
+    /// @param sampling the interpolation sampling
+    InterpolateAttribute(ProgramID pid,
+                         NodeID nid,
+                         const Source& src,
+                         InterpolationType type,
+                         InterpolationSampling sampling);
+    ~InterpolateAttribute() override;
+
+    /// @returns the WGSL name for the attribute
+    std::string Name() const override;
+
+    /// Clones this node and all transitive child nodes using the `CloneContext`
+    /// `ctx`.
+    /// @param ctx the clone context
+    /// @return the newly cloned node
+    const InterpolateAttribute* Clone(CloneContext* ctx) const override;
+
+    /// The interpolation type
+    const InterpolationType type;
+
+    /// The interpolation sampling
+    const InterpolationSampling sampling;
+};
+
+}  // namespace tint::ast
+
+#endif  // SRC_TINT_AST_INTERPOLATE_ATTRIBUTE_H_
diff --git a/src/tint/ast/pointer.cc b/src/tint/ast/pointer.cc
index 71b7004..96bbdaf 100644
--- a/src/tint/ast/pointer.cc
+++ b/src/tint/ast/pointer.cc
@@ -35,7 +35,7 @@
         out << address_space << ", ";
     }
     out << type->FriendlyName(symbols);
-    if (access != ast::Access::kUndefined) {
+    if (access != ast::Access::kInvalid) {
         out << ", " << access;
     }
     out << ">";
diff --git a/src/tint/ast/pointer_test.cc b/src/tint/ast/pointer_test.cc
index aea260a..56a04b0 100644
--- a/src/tint/ast/pointer_test.cc
+++ b/src/tint/ast/pointer_test.cc
@@ -32,7 +32,7 @@
 
 TEST_F(AstPointerTest, FriendlyName) {
     auto* i32 = create<I32>();
-    auto* p = create<Pointer>(i32, ast::AddressSpace::kWorkgroup, Access::kUndefined);
+    auto* p = create<Pointer>(i32, ast::AddressSpace::kWorkgroup, Access::kInvalid);
     EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<workgroup, i32>");
 }
 
diff --git a/src/tint/ast/texel_format.cc b/src/tint/ast/texel_format.cc
index cfac9f1..201cad3 100644
--- a/src/tint/ast/texel_format.cc
+++ b/src/tint/ast/texel_format.cc
@@ -28,8 +28,44 @@
 /// @param str the string to parse
 /// @returns the parsed enum, or TexelFormat::kInvalid if the string could not be parsed.
 TexelFormat ParseTexelFormat(std::string_view str) {
-    if (str == "rgba8unorm") {
-        return TexelFormat::kRgba8Unorm;
+    if (str == "r32float") {
+        return TexelFormat::kR32Float;
+    }
+    if (str == "r32sint") {
+        return TexelFormat::kR32Sint;
+    }
+    if (str == "r32uint") {
+        return TexelFormat::kR32Uint;
+    }
+    if (str == "rg32float") {
+        return TexelFormat::kRg32Float;
+    }
+    if (str == "rg32sint") {
+        return TexelFormat::kRg32Sint;
+    }
+    if (str == "rg32uint") {
+        return TexelFormat::kRg32Uint;
+    }
+    if (str == "rgba16float") {
+        return TexelFormat::kRgba16Float;
+    }
+    if (str == "rgba16sint") {
+        return TexelFormat::kRgba16Sint;
+    }
+    if (str == "rgba16uint") {
+        return TexelFormat::kRgba16Uint;
+    }
+    if (str == "rgba32float") {
+        return TexelFormat::kRgba32Float;
+    }
+    if (str == "rgba32sint") {
+        return TexelFormat::kRgba32Sint;
+    }
+    if (str == "rgba32uint") {
+        return TexelFormat::kRgba32Uint;
+    }
+    if (str == "rgba8sint") {
+        return TexelFormat::kRgba8Sint;
     }
     if (str == "rgba8snorm") {
         return TexelFormat::kRgba8Snorm;
@@ -37,44 +73,8 @@
     if (str == "rgba8uint") {
         return TexelFormat::kRgba8Uint;
     }
-    if (str == "rgba8sint") {
-        return TexelFormat::kRgba8Sint;
-    }
-    if (str == "rgba16uint") {
-        return TexelFormat::kRgba16Uint;
-    }
-    if (str == "rgba16sint") {
-        return TexelFormat::kRgba16Sint;
-    }
-    if (str == "rgba16float") {
-        return TexelFormat::kRgba16Float;
-    }
-    if (str == "r32uint") {
-        return TexelFormat::kR32Uint;
-    }
-    if (str == "r32sint") {
-        return TexelFormat::kR32Sint;
-    }
-    if (str == "r32float") {
-        return TexelFormat::kR32Float;
-    }
-    if (str == "rg32uint") {
-        return TexelFormat::kRg32Uint;
-    }
-    if (str == "rg32sint") {
-        return TexelFormat::kRg32Sint;
-    }
-    if (str == "rg32float") {
-        return TexelFormat::kRg32Float;
-    }
-    if (str == "rgba32uint") {
-        return TexelFormat::kRgba32Uint;
-    }
-    if (str == "rgba32sint") {
-        return TexelFormat::kRgba32Sint;
-    }
-    if (str == "rgba32float") {
-        return TexelFormat::kRgba32Float;
+    if (str == "rgba8unorm") {
+        return TexelFormat::kRgba8Unorm;
     }
     return TexelFormat::kInvalid;
 }
@@ -83,38 +83,38 @@
     switch (value) {
         case TexelFormat::kInvalid:
             return out << "invalid";
-        case TexelFormat::kRgba8Unorm:
-            return out << "rgba8unorm";
+        case TexelFormat::kR32Float:
+            return out << "r32float";
+        case TexelFormat::kR32Sint:
+            return out << "r32sint";
+        case TexelFormat::kR32Uint:
+            return out << "r32uint";
+        case TexelFormat::kRg32Float:
+            return out << "rg32float";
+        case TexelFormat::kRg32Sint:
+            return out << "rg32sint";
+        case TexelFormat::kRg32Uint:
+            return out << "rg32uint";
+        case TexelFormat::kRgba16Float:
+            return out << "rgba16float";
+        case TexelFormat::kRgba16Sint:
+            return out << "rgba16sint";
+        case TexelFormat::kRgba16Uint:
+            return out << "rgba16uint";
+        case TexelFormat::kRgba32Float:
+            return out << "rgba32float";
+        case TexelFormat::kRgba32Sint:
+            return out << "rgba32sint";
+        case TexelFormat::kRgba32Uint:
+            return out << "rgba32uint";
+        case TexelFormat::kRgba8Sint:
+            return out << "rgba8sint";
         case TexelFormat::kRgba8Snorm:
             return out << "rgba8snorm";
         case TexelFormat::kRgba8Uint:
             return out << "rgba8uint";
-        case TexelFormat::kRgba8Sint:
-            return out << "rgba8sint";
-        case TexelFormat::kRgba16Uint:
-            return out << "rgba16uint";
-        case TexelFormat::kRgba16Sint:
-            return out << "rgba16sint";
-        case TexelFormat::kRgba16Float:
-            return out << "rgba16float";
-        case TexelFormat::kR32Uint:
-            return out << "r32uint";
-        case TexelFormat::kR32Sint:
-            return out << "r32sint";
-        case TexelFormat::kR32Float:
-            return out << "r32float";
-        case TexelFormat::kRg32Uint:
-            return out << "rg32uint";
-        case TexelFormat::kRg32Sint:
-            return out << "rg32sint";
-        case TexelFormat::kRg32Float:
-            return out << "rg32float";
-        case TexelFormat::kRgba32Uint:
-            return out << "rgba32uint";
-        case TexelFormat::kRgba32Sint:
-            return out << "rgba32sint";
-        case TexelFormat::kRgba32Float:
-            return out << "rgba32float";
+        case TexelFormat::kRgba8Unorm:
+            return out << "rgba8unorm";
     }
     return out << "<unknown>";
 }
diff --git a/src/tint/ast/texel_format.h b/src/tint/ast/texel_format.h
index 28119b3..9c65fb6 100644
--- a/src/tint/ast/texel_format.h
+++ b/src/tint/ast/texel_format.h
@@ -30,22 +30,22 @@
 /// Enumerator of texel formats
 enum class TexelFormat {
     kInvalid,
-    kRgba8Unorm,
+    kR32Float,
+    kR32Sint,
+    kR32Uint,
+    kRg32Float,
+    kRg32Sint,
+    kRg32Uint,
+    kRgba16Float,
+    kRgba16Sint,
+    kRgba16Uint,
+    kRgba32Float,
+    kRgba32Sint,
+    kRgba32Uint,
+    kRgba8Sint,
     kRgba8Snorm,
     kRgba8Uint,
-    kRgba8Sint,
-    kRgba16Uint,
-    kRgba16Sint,
-    kRgba16Float,
-    kR32Uint,
-    kR32Sint,
-    kR32Float,
-    kRg32Uint,
-    kRg32Sint,
-    kRg32Float,
-    kRgba32Uint,
-    kRgba32Sint,
-    kRgba32Float,
+    kRgba8Unorm,
 };
 
 /// @param out the std::ostream to write to
@@ -58,6 +58,12 @@
 /// @returns the parsed enum, or TexelFormat::kInvalid if the string could not be parsed.
 TexelFormat ParseTexelFormat(std::string_view str);
 
+constexpr const char* kTexelFormatStrings[] = {
+    "r32float",    "r32sint",    "r32uint",    "rg32float",   "rg32sint",   "rg32uint",
+    "rgba16float", "rgba16sint", "rgba16uint", "rgba32float", "rgba32sint", "rgba32uint",
+    "rgba8sint",   "rgba8snorm", "rgba8uint",  "rgba8unorm",
+};
+
 }  // namespace tint::ast
 
 #endif  // SRC_TINT_AST_TEXEL_FORMAT_H_
diff --git a/src/tint/ast/texel_format_bench.cc b/src/tint/ast/texel_format_bench.cc
index a17906a..c48e0f6 100644
--- a/src/tint/ast/texel_format_bench.cc
+++ b/src/tint/ast/texel_format_bench.cc
@@ -31,29 +31,29 @@
 
 void TexelFormatParser(::benchmark::State& state) {
     std::array kStrings{
-        "rgbaunccrm",    "rlbanr3",        "rVba8unorm",     "rgba8unorm",   "rgba1unorm",
-        "rgbJqqnorm",    "rgb7ll8unorm",   "rgqqappnoHHm",   "rv8scor",      "rgbbGsnrm",
-        "rgba8snorm",    "rgba8vniirm",    "rg8a8snoWWm",    "Mgbaxxnorm",   "rXa8uggnt",
-        "rgbXVut",       "3gba8uint",      "rgba8uint",      "rgba8uiEt",    "rgTTPauint",
-        "ddgbauixxt",    "44gba8sint",     "VVgbaSSsint",    "rba8si2Rt",    "rgba8sint",
-        "r9bFsint",      "rgba8int",       "rgVROOsHnt",     "ryba1uint",    "r77ba1nnullrrt",
-        "rgb4006uint",   "rgba16uint",     "rb1uioot",       "rga1uzznt",    "r11b1uppiit",
-        "XXgba16sint",   "IIgb9916nni55t", "rYbaSSrrsiHHat", "rgba16sint",   "rbkk6Hit",
-        "jgba1sgRR",     "rgbab6si",       "rgba16fljat",    "rgba6float",   "rbq6float",
-        "rgba16float",   "rgba1NNloat",    "rgbvv6flot",     "rgbaQQ6foat",  "r3ffir",
-        "r32uijt",       "rNNwuin8",       "r32uint",        "r32int",       "rrr2uint",
-        "G32uint",       "r32sinFF",       "32st",           "r3rrint",      "r32sint",
-        "2sint",         "D3siJJt",        "r38n",           "r211lk",       "r32floa",
-        "r3flJat",       "r32float",       "r32fcoat",       "r32floOt",     "r32floKK_vtt",
-        "rxx32ui8",      "Fg3qq__n",       "rg32iqqt",       "rg32uint",     "rg333uin6",
-        "rtto62u9QQt",   "rg366uin",       "rOx2si6zz",      "rg3yysint",    "rHHsint",
-        "rg32sint",      "qWW432snt",      "rg3OOsnt",       "g32siYt",      "g32flo",
-        "rg32foaF",      "rg32fwat",       "rg32float",      "G3fKoaff",     "KKgq2float",
-        "rg32mmlo3t",    "rgba32uit",      "rqba3uint",      "rgbabb2uin",   "rgba32uint",
-        "rba32iint",     "qgba32uiOt",     "rgba32uiTTvv",   "rgFFa32sint",  "rg00Q2sPnt",
-        "rgbaP2sint",    "rgba32sint",     "rgb77s2sint",    "rgba32sbbRRC", "rgbXX32sint",
-        "rOOOba3CCqoat", "rgbu32fsLt",     "rgba3Xfloat",    "rgba32float",  "rba32float",
-        "qqb3float",     "rgba32fl22at",
+        "rcc2flot",      "3flo3",        "r32flVat",     "r32float",    "132float",
+        "32Jlqqat",      "ll3277loat",   "ppqq2snHH",    "r3cv",        "b2siGt",
+        "r32sint",       "r32siivt",     "8WW2sint",     "rxxsint",     "rXuingg",
+        "3uiXt",         "r32u3nt",      "r32uint",      "E32uint",     "rPTTuint",
+        "r32uidxx",      "44g32float",   "VVg32SSloat",  "r32flo2Rt",   "rg32float",
+        "r93Float",      "rg32foat",     "rgVROOlHat",   "rg3ysin",     "77grr2sllnnt",
+        "04g32sint",     "rg32sint",     "g3oont",       "rg32zzt",     "rgiipps1n",
+        "XXg32uint",     "rII39955nnnt", "aagHH2uinYSS", "rg32uint",    "rkk3it",
+        "gj3uRRn",       "r3bunt",       "rgba16fljat",  "rgba6float",  "rbq6float",
+        "rgba16float",   "rgba1NNloat",  "rgbvv6flot",   "rgbaQQ6foat", "rgb6srnff",
+        "rgba16sijt",    "NNgba16ww2t",  "rgba16sint",   "rgba16snt",   "rgba16rrint",
+        "rgba1Gsint",    "rgba16uFFnt",  "g16uEnt",      "rgb16rrint",  "rgba16uint",
+        "gba16uit",      "rXa1DuiJJt",   "rgauint",      "rga32klot",   "rgb32float",
+        "rgJa32flot",    "rgba32float",  "rgba32fcoat",  "rgba32floOt", "__gttavv2fKKoat",
+        "rg5a32xxnt",    "__ba3sqqFt",   "rgbqq2sint",   "rgba32sint",  "33ba32s66nt",
+        "rtt6a3QQooint", "r66ba3sint",   "xba32zzinO6",  "ryyba32uint", "rbZ32HinZ",
+        "rgba32uint",    "rgba3u4WWnq",  "rgba32uOOt",   "oogba2Yin",   "gba8si",
+        "rgba8inF",      "rgba8wnt",     "rgba8sint",    "Gb8Kinff",    "KKgqa8sint",
+        "rgbammsi3t",    "rgba8snom",    "rqba8norm",    "rgbabbsnor",  "rgba8snorm",
+        "rba8siorm",     "qgba8snoOm",   "rgba8snoTTvv", "rgbaFFuint",  "rgQa00uiP",
+        "rgPa8uint",     "rgba8uint",    "rgssa77unt",   "Cgbbb8uiRRt", "rgba8uinXX",
+        "CqgbaOOunorm",  "rgbu8usrL",    "rgba8Xnorm",   "rgba8unorm",  "rgba8unrm",
+        "ba8uqqor",      "rgba8unor22",
     };
     for (auto _ : state) {
         for (auto& str : kStrings) {
diff --git a/src/tint/ast/texel_format_test.cc b/src/tint/ast/texel_format_test.cc
index 606d78f..d431918 100644
--- a/src/tint/ast/texel_format_test.cc
+++ b/src/tint/ast/texel_format_test.cc
@@ -42,41 +42,41 @@
 }
 
 static constexpr Case kValidCases[] = {
-    {"rgba8unorm", TexelFormat::kRgba8Unorm},   {"rgba8snorm", TexelFormat::kRgba8Snorm},
-    {"rgba8uint", TexelFormat::kRgba8Uint},     {"rgba8sint", TexelFormat::kRgba8Sint},
-    {"rgba16uint", TexelFormat::kRgba16Uint},   {"rgba16sint", TexelFormat::kRgba16Sint},
-    {"rgba16float", TexelFormat::kRgba16Float}, {"r32uint", TexelFormat::kR32Uint},
-    {"r32sint", TexelFormat::kR32Sint},         {"r32float", TexelFormat::kR32Float},
-    {"rg32uint", TexelFormat::kRg32Uint},       {"rg32sint", TexelFormat::kRg32Sint},
-    {"rg32float", TexelFormat::kRg32Float},     {"rgba32uint", TexelFormat::kRgba32Uint},
-    {"rgba32sint", TexelFormat::kRgba32Sint},   {"rgba32float", TexelFormat::kRgba32Float},
+    {"r32float", TexelFormat::kR32Float},       {"r32sint", TexelFormat::kR32Sint},
+    {"r32uint", TexelFormat::kR32Uint},         {"rg32float", TexelFormat::kRg32Float},
+    {"rg32sint", TexelFormat::kRg32Sint},       {"rg32uint", TexelFormat::kRg32Uint},
+    {"rgba16float", TexelFormat::kRgba16Float}, {"rgba16sint", TexelFormat::kRgba16Sint},
+    {"rgba16uint", TexelFormat::kRgba16Uint},   {"rgba32float", TexelFormat::kRgba32Float},
+    {"rgba32sint", TexelFormat::kRgba32Sint},   {"rgba32uint", TexelFormat::kRgba32Uint},
+    {"rgba8sint", TexelFormat::kRgba8Sint},     {"rgba8snorm", TexelFormat::kRgba8Snorm},
+    {"rgba8uint", TexelFormat::kRgba8Uint},     {"rgba8unorm", TexelFormat::kRgba8Unorm},
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"rgbaunccrm", TexelFormat::kInvalid},   {"rlbanr3", TexelFormat::kInvalid},
-    {"rVba8unorm", TexelFormat::kInvalid},   {"rgba1snorm", TexelFormat::kInvalid},
-    {"rgbJqqnorm", TexelFormat::kInvalid},   {"rgb7ll8snorm", TexelFormat::kInvalid},
-    {"rgbauippqHH", TexelFormat::kInvalid},  {"rgbaun", TexelFormat::kInvalid},
-    {"rba8Gint", TexelFormat::kInvalid},     {"rgvia8sint", TexelFormat::kInvalid},
-    {"rgba8WWint", TexelFormat::kInvalid},   {"rgbasxxMt", TexelFormat::kInvalid},
-    {"rXba16ungg", TexelFormat::kInvalid},   {"rba1XuVt", TexelFormat::kInvalid},
-    {"rgba16uin3", TexelFormat::kInvalid},   {"rgba16sinE", TexelFormat::kInvalid},
-    {"TTgba16sPPn", TexelFormat::kInvalid},  {"rgbad6xxint", TexelFormat::kInvalid},
-    {"rgba446float", TexelFormat::kInvalid}, {"SSVVba16float", TexelFormat::kInvalid},
-    {"rgbRR6float", TexelFormat::kInvalid},  {"rFui9t", TexelFormat::kInvalid},
-    {"r32int", TexelFormat::kInvalid},       {"VOORRHnt", TexelFormat::kInvalid},
-    {"r3siyt", TexelFormat::kInvalid},       {"lln3rrs77nt", TexelFormat::kInvalid},
-    {"r32s4n00", TexelFormat::kInvalid},     {"32ooat", TexelFormat::kInvalid},
-    {"r32fzzt", TexelFormat::kInvalid},      {"r3iippl1a", TexelFormat::kInvalid},
-    {"XXg32uint", TexelFormat::kInvalid},    {"rII39955nnnt", TexelFormat::kInvalid},
-    {"aagHH2uinYSS", TexelFormat::kInvalid}, {"rkk3it", TexelFormat::kInvalid},
-    {"gj3sRRn", TexelFormat::kInvalid},      {"r3bsnt", TexelFormat::kInvalid},
-    {"rg32flojt", TexelFormat::kInvalid},    {"r32floa", TexelFormat::kInvalid},
-    {"rg32lot", TexelFormat::kInvalid},      {"rgb3uit", TexelFormat::kInvalid},
-    {"rgjj3uint", TexelFormat::kInvalid},    {"rgb2urnff", TexelFormat::kInvalid},
-    {"rgba32sijt", TexelFormat::kInvalid},   {"NNgba32ww2t", TexelFormat::kInvalid},
-    {"rgba32snt", TexelFormat::kInvalid},    {"rgba32rrloat", TexelFormat::kInvalid},
-    {"rgGa32float", TexelFormat::kInvalid},  {"FFgba32float", TexelFormat::kInvalid},
+    {"rcc2flot", TexelFormat::kInvalid},       {"3flo3", TexelFormat::kInvalid},
+    {"r32flVat", TexelFormat::kInvalid},       {"r32s1nt", TexelFormat::kInvalid},
+    {"rq2Jint", TexelFormat::kInvalid},        {"r32sin7ll", TexelFormat::kInvalid},
+    {"ppqq2unHH", TexelFormat::kInvalid},      {"r3cv", TexelFormat::kInvalid},
+    {"b2uiGt", TexelFormat::kInvalid},         {"rgvi2float", TexelFormat::kInvalid},
+    {"rg328WWoat", TexelFormat::kInvalid},     {"rg32lxxMt", TexelFormat::kInvalid},
+    {"rgXggsnt", TexelFormat::kInvalid},       {"rgXsnu", TexelFormat::kInvalid},
+    {"rg32s3nt", TexelFormat::kInvalid},       {"rg3Euint", TexelFormat::kInvalid},
+    {"PP32TTint", TexelFormat::kInvalid},      {"xxg32ddnt", TexelFormat::kInvalid},
+    {"rgba446float", TexelFormat::kInvalid},   {"SSVVba16float", TexelFormat::kInvalid},
+    {"rgbRR6float", TexelFormat::kInvalid},    {"rga16Fint", TexelFormat::kInvalid},
+    {"rgb16sint", TexelFormat::kInvalid},      {"ORVHa16sint", TexelFormat::kInvalid},
+    {"ryba1uint", TexelFormat::kInvalid},      {"r77ba1nnullrrt", TexelFormat::kInvalid},
+    {"rgb4006uint", TexelFormat::kInvalid},    {"rboofloat", TexelFormat::kInvalid},
+    {"rgbaz2loat", TexelFormat::kInvalid},     {"ppga3ii1floa", TexelFormat::kInvalid},
+    {"XXgba32sint", TexelFormat::kInvalid},    {"IIgb9932nni55t", TexelFormat::kInvalid},
+    {"rYbaSSrrsiHHat", TexelFormat::kInvalid}, {"rbkk2Hit", TexelFormat::kInvalid},
+    {"jgba3ugRR", TexelFormat::kInvalid},      {"rgbab2ui", TexelFormat::kInvalid},
+    {"rgba8sijt", TexelFormat::kInvalid},      {"rba8sint", TexelFormat::kInvalid},
+    {"rba8sqt", TexelFormat::kInvalid},        {"rgba8NNnom", TexelFormat::kInvalid},
+    {"rga8vvorm", TexelFormat::kInvalid},      {"rgba8snorQ", TexelFormat::kInvalid},
+    {"rgbauirf", TexelFormat::kInvalid},       {"rgbajuint", TexelFormat::kInvalid},
+    {"wNNgbauin2", TexelFormat::kInvalid},     {"rgba8unrm", TexelFormat::kInvalid},
+    {"rgba8urrorm", TexelFormat::kInvalid},    {"rgba8Gnorm", TexelFormat::kInvalid},
 };
 
 using TexelFormatParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/inspector/entry_point.cc b/src/tint/inspector/entry_point.cc
index 6d3419f..8cbca14 100644
--- a/src/tint/inspector/entry_point.cc
+++ b/src/tint/inspector/entry_point.cc
@@ -35,32 +35,5 @@
 EntryPoint::EntryPoint(EntryPoint&&) = default;
 EntryPoint::~EntryPoint() = default;
 
-InterpolationType ASTToInspectorInterpolationType(ast::InterpolationType ast_type) {
-    switch (ast_type) {
-        case ast::InterpolationType::kPerspective:
-            return InterpolationType::kPerspective;
-        case ast::InterpolationType::kLinear:
-            return InterpolationType::kLinear;
-        case ast::InterpolationType::kFlat:
-            return InterpolationType::kFlat;
-    }
-
-    return InterpolationType::kUnknown;
-}
-
-InterpolationSampling ASTToInspectorInterpolationSampling(ast::InterpolationSampling sampling) {
-    switch (sampling) {
-        case ast::InterpolationSampling::kNone:
-            return InterpolationSampling::kNone;
-        case ast::InterpolationSampling::kCenter:
-            return InterpolationSampling::kCenter;
-        case ast::InterpolationSampling::kCentroid:
-            return InterpolationSampling::kCentroid;
-        case ast::InterpolationSampling::kSample:
-            return InterpolationSampling::kSample;
-    }
-
-    return InterpolationSampling::kUnknown;
-}
 
 }  // namespace tint::inspector
diff --git a/src/tint/inspector/entry_point.h b/src/tint/inspector/entry_point.h
index 5d119d4..4a4706b 100644
--- a/src/tint/inspector/entry_point.h
+++ b/src/tint/inspector/entry_point.h
@@ -84,17 +84,6 @@
     InterpolationSampling interpolation_sampling = InterpolationSampling::kUnknown;
 };
 
-/// Convert from internal ast::InterpolationType to public ::InterpolationType.
-/// @param ast_type internal value to convert from
-/// @returns the publicly visible equivalent
-InterpolationType ASTToInspectorInterpolationType(ast::InterpolationType ast_type);
-
-/// Convert from internal ast::InterpolationSampling to public
-/// ::InterpolationSampling
-/// @param sampling internal value to convert from
-/// @returns the publicly visible equivalent
-InterpolationSampling ASTToInspectorInterpolationSampling(ast::InterpolationSampling sampling);
-
 /// Reflection data about an override variable referenced by an entry point
 struct Override {
     /// Name of the override
@@ -175,6 +164,8 @@
     bool sample_index_used = false;
     /// Does the entry point use the num_workgroups builtin
     bool num_workgroups_used = false;
+    /// Does the entry point use the frag_depth builtin
+    bool frag_depth_used = false;
 };
 
 }  // namespace tint::inspector
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index 3520ae3..ddb5b11 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -117,14 +117,45 @@
         return {InterpolationType::kPerspective, InterpolationSampling::kCenter};
     }
 
-    auto interpolation_type = interpolation_attribute->type;
-    auto sampling = interpolation_attribute->sampling;
-    if (interpolation_type != ast::InterpolationType::kFlat &&
-        sampling == ast::InterpolationSampling::kNone) {
-        sampling = ast::InterpolationSampling::kCenter;
+    auto ast_interpolation_type = interpolation_attribute->type;
+    auto ast_sampling_type = interpolation_attribute->sampling;
+    if (ast_interpolation_type != ast::InterpolationType::kFlat &&
+        ast_sampling_type == ast::InterpolationSampling::kInvalid) {
+        ast_sampling_type = ast::InterpolationSampling::kCenter;
     }
-    return {ASTToInspectorInterpolationType(interpolation_type),
-            ASTToInspectorInterpolationSampling(sampling)};
+
+    auto interpolation_type = InterpolationType::kUnknown;
+    switch (ast_interpolation_type) {
+        case ast::InterpolationType::kPerspective:
+            interpolation_type = InterpolationType::kPerspective;
+            break;
+        case ast::InterpolationType::kLinear:
+            interpolation_type = InterpolationType::kLinear;
+            break;
+        case ast::InterpolationType::kFlat:
+            interpolation_type = InterpolationType::kFlat;
+            break;
+        case ast::InterpolationType::kInvalid:
+            break;
+    }
+
+    auto sampling_type = InterpolationSampling::kUnknown;
+    switch (ast_sampling_type) {
+        case ast::InterpolationSampling::kInvalid:
+            sampling_type = InterpolationSampling::kNone;
+            break;
+        case ast::InterpolationSampling::kCenter:
+            sampling_type = InterpolationSampling::kCenter;
+            break;
+        case ast::InterpolationSampling::kCentroid:
+            sampling_type = InterpolationSampling::kCentroid;
+            break;
+        case ast::InterpolationSampling::kSample:
+            sampling_type = InterpolationSampling::kSample;
+            break;
+    }
+
+    return {interpolation_type, sampling_type};
 }
 
 }  // namespace
@@ -192,6 +223,8 @@
 
         entry_point.output_sample_mask_used = ContainsBuiltin(
             ast::BuiltinValue::kSampleMask, sem->ReturnType(), func->return_type_attributes);
+        entry_point.frag_depth_used = ContainsBuiltin(
+            ast::BuiltinValue::kFragDepth, sem->ReturnType(), func->return_type_attributes);
     }
 
     for (auto* var : sem->TransitivelyReferencedGlobals()) {
diff --git a/src/tint/inspector/inspector_test.cc b/src/tint/inspector/inspector_test.cc
index 7e81ba0..7aa017c 100644
--- a/src/tint/inspector/inspector_test.cc
+++ b/src/tint/inspector/inspector_test.cc
@@ -852,6 +852,7 @@
     EXPECT_FALSE(result[0].front_facing_used);
     EXPECT_FALSE(result[0].sample_index_used);
     EXPECT_FALSE(result[0].num_workgroups_used);
+    EXPECT_FALSE(result[0].frag_depth_used);
 }
 
 TEST_F(InspectorGetEntryPointTest, InputSampleMaskSimpleReferenced) {
@@ -1134,6 +1135,49 @@
     EXPECT_TRUE(result[0].num_workgroups_used);
 }
 
+TEST_F(InspectorGetEntryPointTest, FragDepthSimpleReferenced) {
+    Func("ep_func", {}, ty.f32(),
+         utils::Vector{
+             Return(Expr(0_f)),
+         },
+         utils::Vector{
+             Stage(ast::PipelineStage::kFragment),
+         },
+         utils::Vector{
+             Builtin(ast::BuiltinValue::kFragDepth),
+         });
+
+    Inspector& inspector = Build();
+
+    auto result = inspector.GetEntryPoints();
+
+    ASSERT_EQ(1u, result.size());
+    EXPECT_TRUE(result[0].frag_depth_used);
+}
+
+TEST_F(InspectorGetEntryPointTest, FragDepthStructReferenced) {
+    Structure("out_struct", utils::Vector{
+                                Member("inner_frag_depth", ty.f32(),
+                                       utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}),
+                            });
+
+    Func("ep_func", utils::Empty, ty.type_name("out_struct"),
+         utils::Vector{
+             Decl(Var("out_var", ty.type_name("out_struct"))),
+             Return("out_var"),
+         },
+         utils::Vector{
+             Stage(ast::PipelineStage::kFragment),
+         });
+
+    Inspector& inspector = Build();
+
+    auto result = inspector.GetEntryPoints();
+
+    ASSERT_EQ(1u, result.size());
+    EXPECT_TRUE(result[0].frag_depth_used);
+}
+
 TEST_F(InspectorGetEntryPointTest, ImplicitInterpolate) {
     Structure("in_struct", utils::Vector{
                                Member("struct_inner", ty.f32(), utils::Vector{Location(0_a)}),
@@ -1206,7 +1250,7 @@
             ast::InterpolationType::kPerspective, ast::InterpolationSampling::kSample,
             InterpolationType::kPerspective, InterpolationSampling::kSample},
         InspectorGetEntryPointInterpolateTestParams{
-            ast::InterpolationType::kPerspective, ast::InterpolationSampling::kNone,
+            ast::InterpolationType::kPerspective, ast::InterpolationSampling::kInvalid,
             InterpolationType::kPerspective, InterpolationSampling::kCenter},
         InspectorGetEntryPointInterpolateTestParams{
             ast::InterpolationType::kLinear, ast::InterpolationSampling::kCenter,
@@ -1218,10 +1262,10 @@
             ast::InterpolationType::kLinear, ast::InterpolationSampling::kSample,
             InterpolationType::kLinear, InterpolationSampling::kSample},
         InspectorGetEntryPointInterpolateTestParams{
-            ast::InterpolationType::kLinear, ast::InterpolationSampling::kNone,
+            ast::InterpolationType::kLinear, ast::InterpolationSampling::kInvalid,
             InterpolationType::kLinear, InterpolationSampling::kCenter},
         InspectorGetEntryPointInterpolateTestParams{
-            ast::InterpolationType::kFlat, ast::InterpolationSampling::kNone,
+            ast::InterpolationType::kFlat, ast::InterpolationSampling::kInvalid,
             InterpolationType::kFlat, InterpolationSampling::kNone}));
 
 TEST_F(InspectorGetOverrideDefaultValuesTest, Bool) {
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index f55b18c..493d224 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -94,6 +94,20 @@
   rgba32float
 }
 
+// https://www.w3.org/TR/WGSL/#interpolation
+enum interpolation_type {
+  perspective
+  linear
+  flat
+}
+
+// https://www.w3.org/TR/WGSL/#interpolation
+enum interpolation_sampling {
+  center
+  centroid
+  sample
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WGSL primitive types                                                       //
 // Types may be decorated with @precedence(N) to prioritize which type        //
@@ -161,13 +175,13 @@
 // A type matcher that can match one or more types.                           //
 ////////////////////////////////////////////////////////////////////////////////
 
-match abstract_or_scalar: ia | fa | f32 | f16 | i32 | u32 | bool
-match scalar: f32 | f16 | i32 | u32 | bool
-match scalar_no_f32: i32 | f16 | u32 | bool
-match scalar_no_f16: f32 | i32 | u32 | bool
-match scalar_no_i32: f32 | f16 | u32 | bool
-match scalar_no_u32: f32 | f16 | i32 | bool
-match scalar_no_bool: f32 | f16 | i32 | u32
+match scalar: ia | fa | f32 | f16 | i32 | u32 | bool
+match concrete_scalar: f32 | f16 | i32 | u32 | bool
+match scalar_no_f32: ia | fa | i32 | f16 | u32 | bool
+match scalar_no_f16: ia | fa | f32 | i32 | u32 | bool
+match scalar_no_i32: ia | fa | f32 | f16 | u32 | bool
+match scalar_no_u32: ia | fa | f32 | f16 | i32 | bool
+match scalar_no_bool: ia | fa | f32 | f16 | i32 | u32
 match fia_fiu32_f16: fa | ia | f32 | i32 | u32 | f16
 match fia_fi32_f16: fa | ia | f32 | i32 | f16
 match fia_fiu32: fa | ia | f32 | i32 | u32
@@ -510,9 +524,9 @@
 fn round<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
 fn saturate<T: f32_f16>(T) -> T
 fn saturate<T: f32_f16, N: num>(vec<N, T>) -> vec<N, T>
-@const("select_bool") fn select<T: abstract_or_scalar>(T, T, bool) -> T
-@const("select_bool") fn select<T: abstract_or_scalar, N: num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T>
-@const("select_boolvec") fn select<N: num, T: abstract_or_scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
+@const("select_bool") fn select<T: scalar>(T, T, bool) -> T
+@const("select_bool") fn select<T: scalar, N: num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T>
+@const("select_boolvec") fn select<N: num, T: scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
 fn sign<T: f32_f16>(T) -> T
 fn sign<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
 fn sin<T: f32_f16>(T) -> T
@@ -706,9 +720,9 @@
 @const("Zero") ctor f32() -> f32
 @const("Zero") ctor f16() -> f16
 @const("Zero") ctor bool() -> bool
-@const("Zero") ctor vec2<T: scalar>() -> vec2<T>
-@const("Zero") ctor vec3<T: scalar>() -> vec3<T>
-@const("Zero") ctor vec4<T: scalar>() -> vec4<T>
+@const("Zero") ctor vec2<T: concrete_scalar>() -> vec2<T>
+@const("Zero") ctor vec3<T: concrete_scalar>() -> vec3<T>
+@const("Zero") ctor vec4<T: concrete_scalar>() -> vec4<T>
 @const("Zero") ctor mat2x2<T: f32_f16>() -> mat2x2<T>
 @const("Zero") ctor mat2x3<T: f32_f16>() -> mat2x3<T>
 @const("Zero") ctor mat2x4<T: f32_f16>() -> mat2x4<T>
@@ -725,9 +739,9 @@
 @const("Identity") ctor f32(f32) -> f32
 @const("Identity") ctor f16(f16) -> f16
 @const("Identity") ctor bool(bool) -> bool
-@const("Identity") ctor vec2<T: scalar>(vec2<T>) -> vec2<T>
-@const("Identity") ctor vec3<T: scalar>(vec3<T>) -> vec3<T>
-@const("Identity") ctor vec4<T: scalar>(vec4<T>) -> vec4<T>
+@const("Identity") ctor vec2<T: concrete_scalar>(vec2<T>) -> vec2<T>
+@const("Identity") ctor vec3<T: concrete_scalar>(vec3<T>) -> vec3<T>
+@const("Identity") ctor vec4<T: concrete_scalar>(vec4<T>) -> vec4<T>
 @const("Identity") ctor mat2x2<T: f32_f16>(mat2x2<T>) -> mat2x2<T>
 @const("Identity") ctor mat2x3<T: f32_f16>(mat2x3<T>) -> mat2x3<T>
 @const("Identity") ctor mat2x4<T: f32_f16>(mat2x4<T>) -> mat2x4<T>
@@ -739,24 +753,24 @@
 @const("Identity") ctor mat4x4<T: f32_f16>(mat4x4<T>) -> mat4x4<T>
 
 // Vector constructors (splat)
-@const("VecSplat") ctor vec2<T: abstract_or_scalar>(T) -> vec2<T>
-@const("VecSplat") ctor vec3<T: abstract_or_scalar>(T) -> vec3<T>
-@const("VecSplat") ctor vec4<T: abstract_or_scalar>(T) -> vec4<T>
+@const("VecSplat") ctor vec2<T: scalar>(T) -> vec2<T>
+@const("VecSplat") ctor vec3<T: scalar>(T) -> vec3<T>
+@const("VecSplat") ctor vec4<T: scalar>(T) -> vec4<T>
 
 // Vector constructors (scalar)
-@const("VecCtorS") ctor vec2<T: abstract_or_scalar>(x: T, y: T) -> vec2<T>
-@const("VecCtorS") ctor vec3<T: abstract_or_scalar>(x: T, y: T, z: T) -> vec3<T>
-@const("VecCtorS") ctor vec4<T: abstract_or_scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
+@const("VecCtorS") ctor vec2<T: scalar>(x: T, y: T) -> vec2<T>
+@const("VecCtorS") ctor vec3<T: scalar>(x: T, y: T, z: T) -> vec3<T>
+@const("VecCtorS") ctor vec4<T: scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
 
 // Vector constructors (mixed)
-@const("VecCtorM") ctor vec3<T: abstract_or_scalar>(xy: vec2<T>, z: T) -> vec3<T>
-@const("VecCtorM") ctor vec3<T: abstract_or_scalar>(x: T, yz: vec2<T>) -> vec3<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xyz: vec3<T>, w: T) -> vec4<T>
-@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, zyw: vec3<T>) -> vec4<T>
+@const("VecCtorM") ctor vec3<T: scalar>(xy: vec2<T>, z: T) -> vec3<T>
+@const("VecCtorM") ctor vec3<T: scalar>(x: T, yz: vec2<T>) -> vec3<T>
+@const("VecCtorM") ctor vec4<T: scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: scalar>(xyz: vec3<T>, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: scalar>(x: T, zyw: vec3<T>) -> vec4<T>
 
 // Matrix constructors (scalar)
 @const("MatCtorS")
@@ -938,11 +952,11 @@
 op && (bool, bool) -> bool
 op || (bool, bool) -> bool
 
-@const op == <T: abstract_or_scalar>(T, T) -> bool
-@const op == <T: abstract_or_scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@const op == <T: scalar>(T, T) -> bool
+@const op == <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
 
-@const op != <T: abstract_or_scalar>(T, T) -> bool
-@const op != <T: abstract_or_scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@const op != <T: scalar>(T, T) -> bool
+@const op != <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
 
 @const op < <T: fia_fiu32_f16>(T, T) -> bool
 @const op < <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index 116660f..2c99b3b 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -173,7 +173,7 @@
 
         const ast::Type* type = nullptr;
         ast::AddressSpace address_space = ast::AddressSpace::kNone;
-        ast::Access access = ast::Access::kUndefined;
+        ast::Access access = ast::Access::kInvalid;
         const ast::Expression* constructor = nullptr;
         utils::Vector<const ast::Attribute*, 4> attributes;
 
@@ -478,11 +478,6 @@
     /// returned`Type` will also be destructed.
     /// Types are unique (de-aliased), and so calling create() for the same `T`
     /// and arguments will return the same pointer.
-    /// @warning Use this method to acquire a type only if all of its type
-    /// information is provided in the constructor arguments `args`.<br>
-    /// If the type requires additional configuration after construction that
-    /// affect its fundamental type, build the type with `std::make_unique`, make
-    /// any necessary alterations and then call unique_type() instead.
     /// @param args the arguments to pass to the type constructor
     /// @returns the de-aliased type pointer
     template <typename T, typename... ARGS>
@@ -907,7 +902,7 @@
         /// @return the pointer to `type` with the given ast::AddressSpace
         const ast::Pointer* pointer(const ast::Type* type,
                                     ast::AddressSpace address_space,
-                                    ast::Access access = ast::Access::kUndefined) const {
+                                    ast::Access access = ast::Access::kInvalid) const {
             return builder->create<ast::Pointer>(type, address_space, access);
         }
 
@@ -919,7 +914,7 @@
         const ast::Pointer* pointer(const Source& source,
                                     const ast::Type* type,
                                     ast::AddressSpace address_space,
-                                    ast::Access access = ast::Access::kUndefined) const {
+                                    ast::Access access = ast::Access::kInvalid) const {
             return builder->create<ast::Pointer>(source, type, address_space, access);
         }
 
@@ -928,7 +923,7 @@
         /// @return the pointer to type `T` with the given ast::AddressSpace.
         template <typename T>
         const ast::Pointer* pointer(ast::AddressSpace address_space,
-                                    ast::Access access = ast::Access::kUndefined) const {
+                                    ast::Access access = ast::Access::kInvalid) const {
             return pointer(Of<T>(), address_space, access);
         }
 
@@ -939,7 +934,7 @@
         template <typename T>
         const ast::Pointer* pointer(const Source& source,
                                     ast::AddressSpace address_space,
-                                    ast::Access access = ast::Access::kUndefined) const {
+                                    ast::Access access = ast::Access::kInvalid) const {
             return pointer(source, Of<T>(), address_space, access);
         }
 
@@ -2914,7 +2909,7 @@
     const ast::InterpolateAttribute* Interpolate(
         const Source& source,
         ast::InterpolationType type,
-        ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone) {
+        ast::InterpolationSampling sampling = ast::InterpolationSampling::kInvalid) {
         return create<ast::InterpolateAttribute>(source, type, sampling);
     }
 
@@ -2924,7 +2919,7 @@
     /// @returns the interpolate attribute pointer
     const ast::InterpolateAttribute* Interpolate(
         ast::InterpolationType type,
-        ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone) {
+        ast::InterpolationSampling sampling = ast::InterpolationSampling::kInvalid) {
         return create<ast::InterpolateAttribute>(source_, type, sampling);
     }
 
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index 4b7b3d3..7bbb5df 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -327,6 +327,8 @@
             return "exp2";
         case GLSLstd450FaceForward:
             return "faceForward";
+        case GLSLstd450FindILsb:
+            return "firstTrailingBit";
         case GLSLstd450Floor:
             return "floor";
         case GLSLstd450Fma:
@@ -427,7 +429,6 @@
         case GLSLstd450PackDouble2x32:
         case GLSLstd450UnpackDouble2x32:
 
-        case GLSLstd450FindILsb:
         case GLSLstd450FindSMsb:
         case GLSLstd450FindUMsb:
 
@@ -2557,6 +2558,8 @@
     }
     auto type_it = identifier_types_.find(id);
     if (type_it != identifier_types_.end()) {
+        // We have a local named definition: function parameter, let, or var
+        // declaration.
         auto name = namer_.Name(id);
         auto* type = type_it->second;
         return TypedExpression{
@@ -2585,10 +2588,13 @@
     switch (inst->opcode()) {
         case SpvOpVariable: {
             // This occurs for module-scope variables.
-            auto name = namer_.Name(inst->result_id());
-            return TypedExpression{
-                parser_impl_.ConvertType(inst->type_id(), PtrAs::Ref),
-                create<ast::IdentifierExpression>(Source{}, builder_.Symbols().Register(name))};
+            auto name = namer_.Name(id);
+            // Construct the reference type, mapping storage class correctly.
+            const auto* type =
+                RemapPointerProperties(parser_impl_.ConvertType(inst->type_id(), PtrAs::Ref), id);
+            // TODO(crbug.com/tint/1041): Fix access mode
+            return TypedExpression{type, create<ast::IdentifierExpression>(
+                                             Source{}, builder_.Symbols().Register(name))};
         }
         case SpvOpUndef:
             // Substitute a null value for undef.
@@ -3356,11 +3362,13 @@
     for (auto id : sorted_by_index(block_info.hoisted_ids)) {
         const auto* def_inst = def_use_mgr_->GetDef(id);
         TINT_ASSERT(Reader, def_inst);
-        auto* storage_type = RemapAddressSpace(parser_impl_.ConvertType(def_inst->type_id()), id);
+        // Compute the store type.  Pointers are not storable, so there is
+        // no need to remap pointer properties.
+        auto* store_type = parser_impl_.ConvertType(def_inst->type_id());
         AddStatement(create<ast::VariableDeclStatement>(
-            Source{}, parser_impl_.MakeVar(id, ast::AddressSpace::kNone, storage_type, nullptr,
+            Source{}, parser_impl_.MakeVar(id, ast::AddressSpace::kNone, store_type, nullptr,
                                            AttributeList{})));
-        auto* type = ty_.Reference(storage_type, ast::AddressSpace::kNone);
+        auto* type = ty_.Reference(store_type, ast::AddressSpace::kNone);
         identifier_types_.emplace(id, type);
     }
 
@@ -3449,6 +3457,7 @@
     }
 
     expr = AddressOfIfNeeded(expr, &inst);
+    expr.type = RemapPointerProperties(expr.type, inst.result_id());
     auto* let = parser_impl_.MakeLet(inst.result_id(), expr.type, expr.expr);
     if (!let) {
         return false;
@@ -3720,7 +3729,6 @@
             if (!expr) {
                 return false;
             }
-            expr.type = RemapAddressSpace(expr.type, result_id);
             return EmitConstDefOrWriteToHoistedVar(inst, expr);
         }
 
@@ -3777,20 +3785,6 @@
     return parser_impl_.RectifyOperandSignedness(inst, std::move(expr));
 }
 
-TypedExpression FunctionEmitter::InferFunctionAddressSpace(TypedExpression expr) {
-    TypedExpression result(expr);
-    if (const auto* ref = expr.type->UnwrapAlias()->As<Reference>()) {
-        if (ref->address_space == ast::AddressSpace::kNone) {
-            expr.type = ty_.Reference(ref->type, ast::AddressSpace::kFunction);
-        }
-    } else if (const auto* ptr = expr.type->UnwrapAlias()->As<Pointer>()) {
-        if (ptr->address_space == ast::AddressSpace::kNone) {
-            expr.type = ty_.Pointer(ptr->type, ast::AddressSpace::kFunction);
-        }
-    }
-    return expr;
-}
-
 TypedExpression FunctionEmitter::MaybeEmitCombinatorialValue(
     const spvtools::opt::Instruction& inst) {
     if (inst.result_id() == 0) {
@@ -4350,6 +4344,10 @@
     const auto num_in_operands = inst.NumInOperands();
 
     bool sink_pointer = false;
+    // The current WGSL expression for the pointer, starting with the base
+    // pointer and updated as each index is incorported.  The important part
+    // is the pointee (or "store type").  The address space and access mode will
+    // be patched as needed at the very end, via RemapPointerProperties.
     TypedExpression current_expr;
 
     // If the variable was originally gl_PerVertex, then in the AST we
@@ -4418,7 +4416,7 @@
     // ever-deeper nested indexing expressions. Start off with an expression
     // for the base, and then bury that inside nested indexing expressions.
     if (!current_expr) {
-        current_expr = InferFunctionAddressSpace(MakeOperand(inst, 0));
+        current_expr = MakeOperand(inst, 0);
         if (current_expr.type->Is<Pointer>()) {
             current_expr = Dereference(current_expr);
         }
@@ -4533,6 +4531,7 @@
         GetDefInfo(inst.result_id())->sink_pointer_source_expr = current_expr;
     }
 
+    current_expr.type = RemapPointerProperties(current_expr.type, inst.result_id());
     return current_expr;
 }
 
@@ -4799,32 +4798,27 @@
             ++index;
             auto& info = def_info_[result_id];
 
-            // Determine address space for pointer values. Do this in order because
-            // we might rely on the address space for a previously-visited definition.
-            // Logical pointers can't be transmitted through OpPhi, so remaining
-            // pointer definitions are SSA values, and their definitions must be
-            // visited before their uses.
             const auto* type = type_mgr_->GetType(inst.type_id());
             if (type) {
+                // Determine address space and access mode for pointer values. Do this in
+                // order because we might rely on the storage class for a previously-visited
+                // definition.
+                // Logical pointers can't be transmitted through OpPhi, so remaining
+                // pointer definitions are SSA values, and their definitions must be
+                // visited before their uses.
                 if (type->AsPointer()) {
-                    if (auto* ast_type = parser_impl_.ConvertType(inst.type_id())) {
-                        if (auto* ptr = ast_type->As<Pointer>()) {
-                            info->pointer.address_space = ptr->address_space;
-                        }
-                    }
                     switch (inst.opcode()) {
                         case SpvOpUndef:
                             return Fail() << "undef pointer is not valid: " << inst.PrettyPrint();
                         case SpvOpVariable:
-                            // Keep the default decision based on the result type.
+                            info->pointer = GetPointerInfo(result_id);
                             break;
                         case SpvOpAccessChain:
                         case SpvOpInBoundsAccessChain:
                         case SpvOpCopyObject:
                             // Inherit from the first operand. We need this so we can pick up
                             // a remapped storage buffer.
-                            info->pointer.address_space =
-                                GetAddressSpaceForPointerValue(inst.GetSingleWordInOperand(0));
+                            info->pointer = GetPointerInfo(inst.GetSingleWordInOperand(0));
                             break;
                         default:
                             return Fail() << "pointer defined in function from unknown opcode: "
@@ -4846,32 +4840,71 @@
     return true;
 }
 
-ast::AddressSpace FunctionEmitter::GetAddressSpaceForPointerValue(uint32_t id) {
+DefInfo::Pointer FunctionEmitter::GetPointerInfo(uint32_t id) {
+    // Compute the result from first principles, for a variable.
+    auto get_from_root_identifier =
+        [&](const spvtools::opt::Instruction& inst) -> DefInfo::Pointer {
+        // WGSL root identifiers (or SPIR-V "memory object declarations") are
+        // either variables or function parameters.
+        switch (inst.opcode()) {
+            case SpvOpVariable: {
+                if (const auto* module_var = parser_impl_.GetModuleVariable(id)) {
+                    return DefInfo::Pointer{module_var->declared_address_space,
+                                            module_var->declared_access};
+                }
+                // Local variables are always Function storage class, with default
+                // access mode.
+                return DefInfo::Pointer{ast::AddressSpace::kFunction, ast::Access::kInvalid};
+            }
+            case SpvOpFunctionParameter: {
+                const auto* type = As<Pointer>(parser_impl_.ConvertType(inst.type_id()));
+                // TODO(crbug.com/tint/1041): Add access mode.
+                // Using kUndefined is ok for now, since the only non-default access mode
+                // on a pointer would be for a storage buffer, and baseline SPIR-V doesn't
+                // allow passing pointers to buffers as function parameters.
+                return DefInfo::Pointer{type->address_space, ast::Access::kInvalid};
+            }
+            default:
+                break;
+        }
+        TINT_ASSERT(Reader, false && "expected a memory object declaration");
+        return {};
+    };
+
     auto where = def_info_.find(id);
     if (where != def_info_.end()) {
-        auto candidate = where->second.get()->pointer.address_space;
-        if (candidate != ast::AddressSpace::kInvalid) {
-            return candidate;
+        const auto& info = where->second;
+        if (info->inst.opcode() == SpvOpVariable) {
+            // Ignore the cache in this case and compute it from scratch.
+            // That's because for a function-scope OpVariable is a
+            // locally-defined value.  So its cache entry has been created
+            // with a default PointerInfo object, which has invalid data.
+            //
+            // Instead, you might think that we could forget this weirdness
+            // and instead have more standard cache-like behaviour. But then
+            // for non-function-scope variables we look up information
+            // from a saved ast::Var. But some builtins don't correspond
+            // to a declared ast::Var. This is simpler and more reliable.
+            return get_from_root_identifier(info->inst);
         }
+        // Use the cached value.
+        return info->pointer;
     }
-    const auto type_id = def_use_mgr_->GetDef(id)->type_id();
-    if (type_id) {
-        auto* ast_type = parser_impl_.ConvertType(type_id);
-        if (auto* ptr = As<Pointer>(ast_type)) {
-            return ptr->address_space;
-        }
-    }
-    return ast::AddressSpace::kInvalid;
+    const auto* inst = def_use_mgr_->GetDef(id);
+    TINT_ASSERT(Reader, inst);
+    return get_from_root_identifier(*inst);
 }
 
-const Type* FunctionEmitter::RemapAddressSpace(const Type* type, uint32_t result_id) {
+const Type* FunctionEmitter::RemapPointerProperties(const Type* type, uint32_t result_id) {
     if (auto* ast_ptr_type = As<Pointer>(type)) {
-        // Remap an old-style storage buffer pointer to a new-style storage
-        // buffer pointer.
-        const auto addr_space = GetAddressSpaceForPointerValue(result_id);
-        if (ast_ptr_type->address_space != addr_space) {
-            return ty_.Pointer(ast_ptr_type->type, addr_space);
-        }
+        const auto pi = GetPointerInfo(result_id);
+        // TODO(crbug.com/tin/t1041): also do access mode
+        return ty_.Pointer(ast_ptr_type->type, pi.address_space);
+    }
+    if (auto* ast_ptr_type = As<Reference>(type)) {
+        const auto pi = GetPointerInfo(result_id);
+        // TODO(crbug.com/tin/t1041): also do access mode
+        return ty_.Reference(ast_ptr_type->type, pi.address_space);
     }
     return type;
 }
diff --git a/src/tint/reader/spirv/function.h b/src/tint/reader/spirv/function.h
index dc6002e..b8240cf 100644
--- a/src/tint/reader/spirv/function.h
+++ b/src/tint/reader/spirv/function.h
@@ -334,7 +334,8 @@
         /// This is kInvalid for non-pointers.
         ast::AddressSpace address_space = ast::AddressSpace::kInvalid;
 
-        // TODO(crbug.com/tint/1041) track access mode.
+        /// The declared access mode.
+        ast::Access access = ast::Access::kInvalid;
     };
 
     /// The expression to use when sinking pointers into their use.
@@ -619,19 +620,23 @@
     /// @returns false on failure
     bool RegisterLocallyDefinedValues();
 
-    /// Returns the Tint address space for the given SPIR-V ID that is a
-    /// pointer value.
+    /// Returns the pointer information needed for the given SPIR-V ID.
+    /// Assumes the given ID yields a value of pointer type.  For IDs
+    /// corresponding to WGSL root identifiers (i.e. OpVariable or
+    /// OpFunctionParameter), the info is computed from scratch.
+    /// Otherwise, this looks up pointer info from a base pointer whose
+    /// data is cached in def_info_.
     /// @param id a SPIR-V ID for a pointer value
-    /// @returns the address space
-    ast::AddressSpace GetAddressSpaceForPointerValue(uint32_t id);
+    /// @returns the associated Pointer info
+    DefInfo::Pointer GetPointerInfo(uint32_t id);
 
-    /// Remaps the address space for the type of a locally-defined value,
-    /// if necessary. If it's not a pointer type, or if its address space
-    /// already matches, then the result is a copy of the `type` argument.
+    /// Remaps the address space and access mode for the type of a
+    /// locally-defined value, if necessary. If it's not a pointer or reference
+    /// type, then the result is a copy of the `type` argument.
     /// @param type the AST type
     /// @param result_id the SPIR-V ID for the locally defined value
     /// @returns an possibly updated type
-    const Type* RemapAddressSpace(const Type* type, uint32_t result_id);
+    const Type* RemapPointerProperties(const Type* type, uint32_t result_id);
 
     /// Marks locally defined values when they should get a 'let'
     /// definition in WGSL, or a 'var' definition at an outer scope.
@@ -1011,13 +1016,6 @@
     /// @returns a new expression node
     TypedExpression MakeOperand(const spvtools::opt::Instruction& inst, uint32_t operand_index);
 
-    /// Copies a typed expression to the result, but when the type is a pointer
-    /// or reference type, ensures the address space is not defaulted.  That is,
-    /// it changes a address space of "none" to "function".
-    /// @param expr a typed expression
-    /// @results a copy of the expression, with possibly updated type
-    TypedExpression InferFunctionAddressSpace(TypedExpression expr);
-
     /// Returns an expression for a SPIR-V OpFMod instruction.
     /// @param inst the SPIR-V instruction
     /// @returns an expression
diff --git a/src/tint/reader/spirv/function_glsl_std_450_test.cc b/src/tint/reader/spirv/function_glsl_std_450_test.cc
index c5131e9..7a4fd94 100644
--- a/src/tint/reader/spirv/function_glsl_std_450_test.cc
+++ b/src/tint/reader/spirv/function_glsl_std_450_test.cc
@@ -179,6 +179,8 @@
     SpvParserTestBase<::testing::TestWithParam<GlslStd450Case>>;
 using SpvParserTest_GlslStd450_Inting_IntingIntingInting =
     SpvParserTestBase<::testing::TestWithParam<GlslStd450Case>>;
+using SpvParserTest_GlslStd450_Uinting_Uinting =
+    SpvParserTestBase<::testing::TestWithParam<GlslStd450Case>>;
 using SpvParserTest_GlslStd450_Uinting_UintingUinting =
     SpvParserTestBase<::testing::TestWithParam<GlslStd450Case>>;
 using SpvParserTest_GlslStd450_Uinting_UintingUintingUinting =
@@ -580,7 +582,8 @@
 
 INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Inting_Inting,
-                         ::testing::Values(GlslStd450Case{"SAbs", "abs"}));
+                         ::testing::Values(GlslStd450Case{"SAbs", "abs"},
+                                           GlslStd450Case{"FindILsb", "firstTrailingBit"}));
 
 INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Inting_IntingInting,
@@ -591,6 +594,41 @@
                          SpvParserTest_GlslStd450_Inting_IntingIntingInting,
                          ::testing::Values(GlslStd450Case{"SClamp", "clamp"}));
 
+TEST_P(SpvParserTest_GlslStd450_Uinting_Uinting, Scalar) {
+    const auto assembly = Preamble() + R"(
+     %1 = OpExtInst %uint %glsl )" +
+                          GetParam().opcode +
+                          R"( %u1
+     OpReturn
+     OpFunctionEnd
+  )";
+    auto p = parser(test::Assemble(assembly));
+    ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
+    auto fe = p->function_emitter(100);
+    EXPECT_TRUE(fe.EmitBody()) << p->error();
+    auto ast_body = fe.ast_body();
+    const auto body = test::ToString(p->program(), ast_body);
+    EXPECT_THAT(body, HasSubstr("let x_1 : u32 = " + GetParam().wgsl_func + "(u1);")) << body;
+}
+
+TEST_P(SpvParserTest_GlslStd450_Uinting_Uinting, Vector) {
+    const auto assembly = Preamble() + R"(
+     %1 = OpExtInst %v2uint %glsl )" +
+                          GetParam().opcode +
+                          R"( %v2u1
+     OpReturn
+     OpFunctionEnd
+  )";
+    auto p = parser(test::Assemble(assembly));
+    ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
+    auto fe = p->function_emitter(100);
+    EXPECT_TRUE(fe.EmitBody()) << p->error();
+    auto ast_body = fe.ast_body();
+    const auto body = test::ToString(p->program(), ast_body);
+    EXPECT_THAT(body, HasSubstr("let x_1 : vec2<u32> = " + GetParam().wgsl_func + "(v2u1);"))
+        << body;
+}
+
 TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Scalar) {
     const auto assembly = Preamble() + R"(
      %1 = OpExtInst %uint %glsl )" +
@@ -662,6 +700,10 @@
 }
 
 INSTANTIATE_TEST_SUITE_P(Samples,
+                         SpvParserTest_GlslStd450_Uinting_Uinting,
+                         ::testing::Values(GlslStd450Case{"FindILsb", "firstTrailingBit"}));
+
+INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Uinting_UintingUinting,
                          ::testing::Values(GlslStd450Case{"UMax", "max"},
                                            GlslStd450Case{"UMin", "min"}));
@@ -907,6 +949,34 @@
         << body;
 }
 
+TEST_F(SpvParserTest, RectifyOperandsAndResult_FindILsb) {
+    // Check conversion of:
+    //   signed results to unsigned result to match first arg.
+    //   unsigned results to signed result to match first arg.
+    // This is the first extended instruction we've supported which goes both
+    // ways.
+    const auto assembly = Preamble() + R"(
+     %1 = OpExtInst %uint %glsl FindILsb %i1
+     %2 = OpExtInst %v2uint %glsl FindILsb %v2i1
+     %3 = OpExtInst %int %glsl FindILsb %u1
+     %4 = OpExtInst %v2int %glsl FindILsb %v2u1
+     OpReturn
+     OpFunctionEnd
+  )";
+    auto p = parser(test::Assemble(assembly));
+    ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
+    auto fe = p->function_emitter(100);
+    EXPECT_TRUE(fe.EmitBody()) << p->error();
+    auto ast_body = fe.ast_body();
+    const auto body = test::ToString(p->program(), ast_body);
+    EXPECT_THAT(body, HasSubstr(R"(
+let x_1 : u32 = bitcast<u32>(firstTrailingBit(i1));
+let x_2 : vec2<u32> = bitcast<vec2<u32>>(firstTrailingBit(v2i1));
+let x_3 : i32 = bitcast<i32>(firstTrailingBit(u1));
+let x_4 : vec2<i32> = bitcast<vec2<i32>>(firstTrailingBit(v2u1));)"))
+        << body;
+}
+
 struct DataPackingCase {
     std::string opcode;
     std::string wgsl_func;
diff --git a/src/tint/reader/spirv/function_memory_test.cc b/src/tint/reader/spirv/function_memory_test.cc
index dbf9219..a64aac5 100644
--- a/src/tint/reader/spirv/function_memory_test.cc
+++ b/src/tint/reader/spirv/function_memory_test.cc
@@ -938,6 +938,43 @@
 )"));
 }
 
+TEST_F(SpvParserMemoryTest, RemapStorageBuffer_ThroughAccessChain_NonCascaded_UsedTwice) {
+    // Use the pointer value twice, which provokes the spirv-reader
+    // to make a let declaration for the pointer.  The storage class
+    // must be 'storage', not 'uniform'.
+    const auto assembly = OldStorageBufferPreamble() + R"(
+  %100 = OpFunction %void None %voidfn
+  %entry = OpLabel
+
+  ; the scalar element
+  %1 = OpAccessChain %ptr_uint %myvar %uint_0
+  OpStore %1 %uint_0
+  OpStore %1 %uint_0
+
+  ; element in the runtime array
+  %2 = OpAccessChain %ptr_uint %myvar %uint_1 %uint_1
+  ; Use the pointer twice
+  %3 = OpLoad %uint %2
+  OpStore %2 %uint_0
+
+  OpReturn
+  OpFunctionEnd
+)";
+    auto p = parser(test::Assemble(assembly));
+    ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
+    auto fe = p->function_emitter(100);
+    EXPECT_TRUE(fe.EmitBody()) << p->error();
+    auto ast_body = fe.ast_body();
+    const auto got = test::ToString(p->program(), ast_body);
+    EXPECT_THAT(got, HasSubstr(R"(let x_1 : ptr<storage, u32> = &(myvar.field0);
+*(x_1) = 0u;
+*(x_1) = 0u;
+let x_2 : ptr<storage, u32> = &(myvar.field1[1u]);
+let x_3 : u32 = *(x_2);
+*(x_2) = 0u;
+)"));
+}
+
 TEST_F(SpvParserMemoryTest, RemapStorageBuffer_ThroughAccessChain_NonCascaded_InBoundsAccessChain) {
     // Like the previous test, but using OpInBoundsAccessChain.
     const auto assembly = OldStorageBufferPreamble() + R"(
@@ -1020,56 +1057,6 @@
     p->SkipDumpingPending("crbug.com/tint/1041 track access mode in spirv-reader parser type");
 }
 
-TEST_F(SpvParserMemoryTest, RemapStorageBuffer_ThroughCopyObject_WithHoisting) {
-    // TODO(dneto): Hoisting non-storable values (pointers) is not yet supported.
-    // It's debatable whether this test should run at all.
-    // crbug.com/tint/98
-
-    // Like the previous test, but the declaration for the copy-object
-    // has its declaration hoisted.
-    const auto assembly = OldStorageBufferPreamble() + R"(
-  %bool = OpTypeBool
-  %cond = OpConstantTrue %bool
-
-  %100 = OpFunction %void None %voidfn
-
-  %entry = OpLabel
-  OpSelectionMerge %99 None
-  OpBranchConditional %cond %20 %30
-
-  %20 = OpLabel
-  %1 = OpAccessChain %ptr_uint %myvar %uint_1 %uint_1
-  ; this definintion dominates the use in %99
-  %2 = OpCopyObject %ptr_uint %1
-  OpBranch %99
-
-  %30 = OpLabel
-  OpReturn
-
-  %99 = OpLabel
-  OpStore %2 %uint_0
-  OpReturn
-
-  OpFunctionEnd
-)";
-    auto p = parser(test::Assemble(assembly));
-    ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
-    auto fe = p->function_emitter(100);
-    EXPECT_TRUE(fe.EmitBody()) << p->error();
-    auto ast_body = fe.ast_body();
-    EXPECT_EQ(test::ToString(p->program(), ast_body),
-              R"(var x_2 : ptr<storage, u32>;
-if (true) {
-  x_2 = &(myvar.field1[1u]);
-} else {
-  return;
-}
-x_2 = 0u;
-return;
-)") << p->error();
-    p->SkipDumpingPending("crbug.com/tint/98");
-}
-
 std::string RuntimeArrayPreamble() {
     return R"(
      OpCapability Shader
diff --git a/src/tint/reader/spirv/parser_impl.cc b/src/tint/reader/spirv/parser_impl.cc
index 5aa68eb..63e5cb4 100644
--- a/src/tint/reader/spirv/parser_impl.cc
+++ b/src/tint/reader/spirv/parser_impl.cc
@@ -221,6 +221,7 @@
         case GLSLstd450UMin:
         case GLSLstd450UMax:
         case GLSLstd450UClamp:
+        case GLSLstd450FindILsb:
             // TODO(dneto): FindSMsb?
             // TODO(dneto): FindUMsb?
             return true;
@@ -1566,7 +1567,7 @@
         return nullptr;
     }
 
-    ast::Access access = ast::Access::kUndefined;
+    ast::Access access = ast::Access::kInvalid;
     if (address_space == ast::AddressSpace::kStorage) {
         bool read_only = false;
         if (auto* tn = storage_type->As<Named>()) {
@@ -1749,7 +1750,7 @@
                                             AttributeList* attributes) {
     // Vulkan defaults to perspective-correct interpolation.
     ast::InterpolationType type = ast::InterpolationType::kPerspective;
-    ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone;
+    ast::InterpolationSampling sampling = ast::InterpolationSampling::kInvalid;
 
     for (const auto& deco : decorations) {
         TINT_ASSERT(Reader, deco.size() > 0);
@@ -1804,7 +1805,7 @@
 
     // Apply interpolation.
     if (type == ast::InterpolationType::kPerspective &&
-        sampling == ast::InterpolationSampling::kNone) {
+        sampling == ast::InterpolationSampling::kInvalid) {
         // This is the default. Don't add a decoration.
     } else {
         attributes->Push(create<ast::InterpolateAttribute>(type, sampling));
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index 50dd191..b042ac2 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -43,6 +43,7 @@
 #include "src/tint/sem/external_texture.h"
 #include "src/tint/sem/multisampled_texture.h"
 #include "src/tint/sem/sampled_texture.h"
+#include "src/tint/utils/string.h"
 
 namespace tint::reader::wgsl {
 namespace {
@@ -370,40 +371,36 @@
         }
 
         // Match the extension name.
-        Expect<std::string> name = {""};
         auto& t = peek();
-        if (t.IsIdentifier()) {
-            synchronized_ = true;
-            next();
-            name = {t.to_str(), t.source()};
-        } else if (t.Is(Token::Type::kF16)) {
-            // `f16` is a valid extension name and also a keyword
-            synchronized_ = true;
-            next();
-            name = {"f16", t.source()};
-        } else if (t.Is(Token::Type::kParenLeft)) {
+        if (handle_error(t)) {
+            // The token might itself be an error.
+            return Failure::kErrored;
+        }
+
+        if (t.Is(Token::Type::kParenLeft)) {
             // A common error case is writing `enable(foo);` instead of `enable foo;`.
             synchronized_ = false;
             return add_error(t.source(), "enable directives don't take parenthesis");
-        } else if (handle_error(t)) {
-            // The token might itself be an error.
-            return Failure::kErrored;
+        }
+
+        auto extension = ast::Extension::kInvalid;
+        if (t.Is(Token::Type::kF16)) {
+            // `f16` is a valid extension name and also a keyword
+            synchronized_ = true;
+            next();
+            extension = ast::Extension::kF16;
         } else {
-            // Failed to match an extension name.
-            synchronized_ = false;
-            return add_error(t.source(), "invalid extension name");
+            auto ext = expect_enum("extension", ast::ParseExtension, ast::kExtensionStrings);
+            if (ext.errored) {
+                return Failure::kErrored;
+            }
+            extension = ext.value;
         }
 
         if (!expect("enable directive", Token::Type::kSemicolon)) {
             return Failure::kErrored;
         }
-
-        auto extension = ast::ParseExtension(name.value);
-        if (extension == ast::Extension::kInvalid) {
-            return add_error(name.source, "unsupported extension: '" + name.value + "'");
-        }
-        builder_.AST().AddEnable(create<ast::Enable>(name.source, extension));
-
+        builder_.AST().AddEnable(create<ast::Enable>(t.source(), extension));
         return kSuccess;
     });
 
@@ -763,7 +760,7 @@
                 return Failure::kErrored;
             }
 
-            auto access = expect_access_mode("access control");
+            auto access = expect_access_mode(use);
             if (access.errored) {
                 return Failure::kErrored;
             }
@@ -920,12 +917,7 @@
 //  | 'rgba32sint'
 //  | 'rgba32float'
 Expect<ast::TexelFormat> ParserImpl::expect_texel_format(std::string_view use) {
-    auto& t = next();
-    auto fmt = ast::ParseTexelFormat(t.to_str());
-    if (fmt == ast::TexelFormat::kInvalid) {
-        return add_error(t.source(), "invalid format", use);
-    }
-    return fmt;
+    return expect_enum("texel format", ast::ParseTexelFormat, ast::kTexelFormatStrings, use);
 }
 
 Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_with_optional_type_specifier(
@@ -975,22 +967,7 @@
 //   | 'write'
 //   | 'read_write'
 Expect<ast::Access> ParserImpl::expect_access_mode(std::string_view use) {
-    auto ident = expect_ident(use);
-    if (ident.errored) {
-        return Failure::kErrored;
-    }
-
-    if (ident.value == "read") {
-        return {ast::Access::kRead, ident.source};
-    }
-    if (ident.value == "write") {
-        return {ast::Access::kWrite, ident.source};
-    }
-    if (ident.value == "read_write") {
-        return {ast::Access::kReadWrite, ident.source};
-    }
-
-    return add_error(ident.source, "invalid value for access control");
+    return expect_enum("access control", ast::ParseAccess, ast::kAccessStrings, use);
 }
 
 // variable_qualifier
@@ -1014,7 +991,7 @@
             }
             return VariableQualifier{sc.value, ac.value};
         }
-        return Expect<VariableQualifier>{VariableQualifier{sc.value, ast::Access::kUndefined},
+        return Expect<VariableQualifier>{VariableQualifier{sc.value, ast::Access::kInvalid},
                                          source};
     });
 
@@ -1194,6 +1171,66 @@
     return type_specifier_without_ident();
 }
 
+template <typename ENUM, size_t N>
+Expect<ENUM> ParserImpl::expect_enum(std::string_view name,
+                                     ENUM (*parse)(std::string_view str),
+                                     const char* const (&strings)[N],
+                                     std::string_view use) {
+    auto& t = peek();
+    if (t.IsIdentifier()) {
+        auto val = parse(t.to_str());
+        if (val != ENUM::kInvalid) {
+            synchronized_ = true;
+            next();
+            return {val, t.source()};
+        }
+    }
+
+    // Was the token itself an error?
+    if (handle_error(t)) {
+        return Failure::kErrored;
+    }
+
+    /// Create a sensible error message
+    std::stringstream err;
+    err << "expected " << name;
+
+    if (!use.empty()) {
+        err << " for " << use;
+    }
+
+    // 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;
+    constexpr size_t kSuggestionMaxLength = 64;
+    if (auto got = t.to_str(); !got.empty() && got.size() < kSuggestionMaxLength) {
+        size_t candidate_dist = kSuggestionDistance;
+        const char* candidate = nullptr;
+        for (auto* str : strings) {
+            auto dist = utils::Distance(str, got);
+            if (dist < candidate_dist) {
+                candidate = str;
+                candidate_dist = dist;
+            }
+        }
+        if (candidate) {
+            err << ". Did you mean '" << candidate << "'?";
+        }
+    }
+
+    // List all the possible enumerator values
+    err << "\nPossible values: ";
+    for (auto* str : strings) {
+        if (str != strings[0]) {
+            err << ", ";
+        }
+        err << "'" << str << "'";
+    }
+
+    synchronized_ = false;
+    return add_error(t.source(), err.str());
+}
+
 Expect<const ast::Type*> ParserImpl::expect_type(std::string_view use) {
     auto type = type_specifier();
     if (type.errored) {
@@ -1210,7 +1247,7 @@
     const char* use = "ptr declaration";
 
     auto address_space = ast::AddressSpace::kNone;
-    auto access = ast::Access::kUndefined;
+    auto access = ast::Access::kInvalid;
 
     auto subtype = expect_lt_gt_block(use, [&]() -> Expect<const ast::Type*> {
         auto sc = expect_address_space(use);
@@ -1229,7 +1266,7 @@
         }
 
         if (match(Token::Type::kComma)) {
-            auto ac = expect_access_mode("access control");
+            auto ac = expect_access_mode(use);
             if (ac.errored) {
                 return Failure::kErrored;
             }
@@ -1331,18 +1368,7 @@
 //
 // Note, we also parse `push_constant` from the experimental extension
 Expect<ast::AddressSpace> ParserImpl::expect_address_space(std::string_view use) {
-    auto& t = peek();
-    auto ident = expect_ident("address space");
-    if (ident.errored) {
-        return Failure::kErrored;
-    }
-
-    auto address_space = ast::ParseAddressSpace(ident.value);
-    if (address_space == ast::AddressSpace::kInvalid) {
-        return add_error(t.source(), "invalid address space", use);
-    }
-
-    return {address_space, t.source()};
+    return expect_enum("address space", ast::ParseAddressSpace, ast::kAddressSpaceStrings, use);
 }
 
 // struct_decl
@@ -1605,25 +1631,12 @@
 }
 
 // interpolation_sample_name
-//   :  'center'
+//   : 'center'
 //   | 'centroid'
 //   | 'sample'
 Expect<ast::InterpolationSampling> ParserImpl::expect_interpolation_sample_name() {
-    auto ident = expect_ident("interpolation sample name");
-    if (ident.errored) {
-        return Failure::kErrored;
-    }
-
-    if (ident.value == "center") {
-        return {ast::InterpolationSampling::kCenter, ident.source};
-    }
-    if (ident.value == "centroid") {
-        return {ast::InterpolationSampling::kCentroid, ident.source};
-    }
-    if (ident.value == "sample") {
-        return {ast::InterpolationSampling::kSample, ident.source};
-    }
-    return add_error(ident.source, "invalid interpolation sampling");
+    return expect_enum("interpolation sampling", ast::ParseInterpolationSampling,
+                       ast::kInterpolationSamplingStrings);
 }
 
 // interpolation_type_name
@@ -1631,22 +1644,8 @@
 //   | 'linear'
 //   | 'flat'
 Expect<ast::InterpolationType> ParserImpl::expect_interpolation_type_name() {
-    auto ident = expect_ident("interpolation type name");
-    if (ident.errored) {
-        return Failure::kErrored;
-    }
-
-    if (ident.value == "perspective") {
-        return {ast::InterpolationType::kPerspective, ident.source};
-    }
-    if (ident.value == "linear") {
-        return {ast::InterpolationType::kLinear, ident.source};
-    }
-    if (ident.value == "flat") {
-        return {ast::InterpolationType::kFlat, ident.source};
-    }
-
-    return add_error(ident.source, "invalid interpolation type");
+    return expect_enum("interpolation type", ast::ParseInterpolationType,
+                       ast::kInterpolationTypeStrings);
 }
 
 // builtin_value_name
@@ -1663,17 +1662,7 @@
 //   | vertex_index
 //   | workgroup_id
 Expect<ast::BuiltinValue> ParserImpl::expect_builtin() {
-    auto ident = expect_ident("builtin");
-    if (ident.errored) {
-        return Failure::kErrored;
-    }
-
-    ast::BuiltinValue builtin = ast::ParseBuiltinValue(ident.value);
-    if (builtin == ast::BuiltinValue::kInvalid) {
-        return add_error(ident.source, "invalid value for builtin attribute");
-    }
-
-    return {builtin, ident.source};
+    return expect_enum("builtin", ast::ParseBuiltinValue, ast::kBuiltinValueStrings);
 }
 
 // compound_statement
@@ -3523,7 +3512,7 @@
                 return Failure::kErrored;
             }
 
-            ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone;
+            ast::InterpolationSampling sampling = ast::InterpolationSampling::kInvalid;
             if (match(Token::Type::kComma)) {
                 if (!peek_is(Token::Type::kParenRight)) {
                     auto sample = expect_interpolation_sample_name();
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index 5ae4c97..77196a0 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -296,7 +296,7 @@
         /// Variable address space
         ast::AddressSpace address_space = ast::AddressSpace::kNone;
         /// Variable access control
-        ast::Access access = ast::Access::kUndefined;
+        ast::Access access = ast::Access::kInvalid;
         /// Variable type
         const ast::Type* type = nullptr;
     };
@@ -306,7 +306,7 @@
         /// The variable's address space
         ast::AddressSpace address_space = ast::AddressSpace::kNone;
         /// The variable's access control
-        ast::Access access = ast::Access::kUndefined;
+        ast::Access access = ast::Access::kInvalid;
     };
 
     /// MatrixDimensions contains the column and row information for a matrix
@@ -868,6 +868,18 @@
     Expect<const ast::Type*> expect_type_specifier_matrix(const Source& s,
                                                           const MatrixDimensions& dims);
 
+    /// Parses the given enum, providing sensible error messages if the next token does not match
+    /// any of the enum values.
+    /// @param name the name of the enumerator
+    /// @param parse the optimized function used to parse the enum
+    /// @param strings the list of possible strings in the enum
+    /// @param use an optional description of what was being parsed if an error was raised.
+    template <typename ENUM, size_t N>
+    Expect<ENUM> expect_enum(std::string_view name,
+                             ENUM (*parse)(std::string_view str),
+                             const char* const (&strings)[N],
+                             std::string_view use = "");
+
     Expect<const ast::Type*> expect_type(std::string_view use);
 
     Maybe<const ast::Statement*> non_block_statement();
diff --git a/src/tint/reader/wgsl/parser_impl_address_space_test.cc b/src/tint/reader/wgsl/parser_impl_address_space_test.cc
index d9d6d5e..251c1d0 100644
--- a/src/tint/reader/wgsl/parser_impl_address_space_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_address_space_test.cc
@@ -54,7 +54,8 @@
     auto sc = p->expect_address_space("test");
     EXPECT_EQ(sc.errored, true);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:1: invalid address space for test");
+    EXPECT_EQ(p->error(), R"(1:1: expected address space for test
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 }  // namespace
diff --git a/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc b/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
index ed57be8..aad8eb6 100644
--- a/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_enable_directive_test.cc
@@ -61,7 +61,21 @@
     p->enable_directive();
     // Error when unknown extension found
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unsupported extension: 'NotAValidExtensionName'");
+    EXPECT_EQ(p->error(), R"(1:8: expected extension
+Possible values: 'chromium_disable_uniformity_analysis', 'chromium_experimental_dp4a', 'chromium_experimental_push_constant', 'f16')");
+    auto program = p->program();
+    auto& ast = program.AST();
+    EXPECT_EQ(ast.Enables().Length(), 0u);
+    EXPECT_EQ(ast.GlobalDeclarations().Length(), 0u);
+}
+
+TEST_F(EnableDirectiveTest, InvalidIdentifierSuggest) {
+    auto p = parser("enable f15;");
+    p->enable_directive();
+    // Error when unknown extension found
+    EXPECT_TRUE(p->has_error());
+    EXPECT_EQ(p->error(), R"(1:8: expected extension. Did you mean 'f16'?
+Possible values: 'chromium_disable_uniformity_analysis', 'chromium_experimental_dp4a', 'chromium_experimental_push_constant', 'f16')");
     auto program = p->program();
     auto& ast = program.AST();
     EXPECT_EQ(ast.Enables().Length(), 0u);
@@ -108,7 +122,8 @@
         auto p = parser("enable <f16;");
         p->translation_unit();
         EXPECT_TRUE(p->has_error());
-        EXPECT_EQ(p->error(), "1:8: invalid extension name");
+        EXPECT_EQ(p->error(), R"(1:8: expected extension
+Possible values: 'chromium_disable_uniformity_analysis', 'chromium_experimental_dp4a', 'chromium_experimental_push_constant', 'f16')");
         auto program = p->program();
         auto& ast = program.AST();
         EXPECT_EQ(ast.Enables().Length(), 0u);
@@ -118,7 +133,8 @@
         auto p = parser("enable =;");
         p->translation_unit();
         EXPECT_TRUE(p->has_error());
-        EXPECT_EQ(p->error(), "1:8: invalid extension name");
+        EXPECT_EQ(p->error(), R"(1:8: expected extension
+Possible values: 'chromium_disable_uniformity_analysis', 'chromium_experimental_dp4a', 'chromium_experimental_push_constant', 'f16')");
         auto program = p->program();
         auto& ast = program.AST();
         EXPECT_EQ(ast.Enables().Length(), 0u);
@@ -128,7 +144,8 @@
         auto p = parser("enable vec4;");
         p->translation_unit();
         EXPECT_TRUE(p->has_error());
-        EXPECT_EQ(p->error(), "1:8: invalid extension name");
+        EXPECT_EQ(p->error(), R"(1:8: expected extension
+Possible values: 'chromium_disable_uniformity_analysis', 'chromium_experimental_dp4a', 'chromium_experimental_push_constant', 'f16')");
         auto program = p->program();
         auto& ast = program.AST();
         EXPECT_EQ(ast.Enables().Length(), 0u);
diff --git a/src/tint/reader/wgsl/parser_impl_error_msg_test.cc b/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
index 7ea5aaa..af9734c 100644
--- a/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
@@ -765,7 +765,8 @@
 }
 
 TEST_F(ParserImplErrorTest, GlobalDeclStaticAssertMissingLParen) {
-    EXPECT("static_assert true);", R"(test.wgsl:1:19 error: expected ';' for static assertion declaration
+    EXPECT("static_assert true);",
+           R"(test.wgsl:1:19 error: expected ';' for static assertion declaration
 static_assert true);
                   ^
 )");
@@ -804,7 +805,8 @@
 
 TEST_F(ParserImplErrorTest, GlobalDeclStorageTextureMissingSubtype) {
     EXPECT("var x : texture_storage_2d<>;",
-           R"(test.wgsl:1:28 error: invalid format for storage texture type
+           R"(test.wgsl:1:28 error: expected texel format for storage texture type
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm'
 var x : texture_storage_2d<>;
                            ^
 )");
@@ -812,7 +814,8 @@
 
 TEST_F(ParserImplErrorTest, GlobalDeclStorageTextureMissingInvalidSubtype) {
     EXPECT("var x : texture_storage_2d<1>;",
-           R"(test.wgsl:1:28 error: invalid format for storage texture type
+           R"(test.wgsl:1:28 error: expected texel format for storage texture type
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm'
 var x : texture_storage_2d<1>;
                            ^
 )");
@@ -989,17 +992,19 @@
 
 TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBuiltinInvalidIdentifer) {
     EXPECT("@builtin(1) var i : i32;",
-           R"(test.wgsl:1:10 error: expected identifier for builtin
+           R"(test.wgsl:1:10 error: expected builtin
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id'
 @builtin(1) var i : i32;
          ^
 )");
 }
 
 TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBuiltinInvalidValue) {
-    EXPECT("@builtin(x) var i : i32;",
-           R"(test.wgsl:1:10 error: invalid value for builtin attribute
-@builtin(x) var i : i32;
-         ^
+    EXPECT("@builtin(frag_d3pth) var i : i32;",
+           R"(test.wgsl:1:10 error: expected builtin. Did you mean 'frag_depth'?
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id'
+@builtin(frag_d3pth) var i : i32;
+         ^^^^^^^^^^
 )");
 }
 
@@ -1107,7 +1112,8 @@
 
 TEST_F(ParserImplErrorTest, GlobalDeclVarPtrMissingAddressSpace) {
     EXPECT("var i : ptr<meow, u32>;",
-           R"(test.wgsl:1:13 error: invalid address space for ptr declaration
+           R"(test.wgsl:1:13 error: expected address space for ptr declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup'
 var i : ptr<meow, u32>;
             ^^^^
 )");
@@ -1139,7 +1145,8 @@
 
 TEST_F(ParserImplErrorTest, GlobalDeclVarStorageDeclInvalidClass) {
     EXPECT("var<fish> i : i32",
-           R"(test.wgsl:1:5 error: invalid address space for variable declaration
+           R"(test.wgsl:1:5 error: expected address space for variable declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup'
 var<fish> i : i32
     ^^^^
 )");
diff --git a/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc b/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc
index d6e475a..388ad67 100644
--- a/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc
@@ -165,7 +165,8 @@
     EXPECT_TRUE(e.errored);
     EXPECT_FALSE(e.matched);
     EXPECT_EQ(e.value, nullptr);
-    EXPECT_EQ(p->error(), "1:5: invalid address space for variable declaration");
+    EXPECT_EQ(p->error(), R"(1:5: expected address space for variable declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 }  // namespace
diff --git a/src/tint/reader/wgsl/parser_impl_texel_format_test.cc b/src/tint/reader/wgsl/parser_impl_texel_format_test.cc
index e7afb9e..1697359 100644
--- a/src/tint/reader/wgsl/parser_impl_texel_format_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_texel_format_test.cc
@@ -17,15 +17,16 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, ImageStorageType_Invalid) {
+TEST_F(ParserImplTest, TexelFormat_Invalid) {
     auto p = parser("1234");
     auto t = p->expect_texel_format("test");
     EXPECT_TRUE(t.errored);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:1: invalid format for test");
+    EXPECT_EQ(p->error(), R"(1:1: expected texel format for test
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm')");
 }
 
-TEST_F(ParserImplTest, ImageStorageType_R32Uint) {
+TEST_F(ParserImplTest, TexelFormat_R32Uint) {
     auto p = parser("r32uint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -33,7 +34,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_R32Sint) {
+TEST_F(ParserImplTest, TexelFormat_R32Sint) {
     auto p = parser("r32sint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -41,7 +42,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_R32Float) {
+TEST_F(ParserImplTest, TexelFormat_R32Float) {
     auto p = parser("r32float");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -49,7 +50,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba8Unorm) {
+TEST_F(ParserImplTest, TexelFormat_Rgba8Unorm) {
     auto p = parser("rgba8unorm");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -57,7 +58,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba8Snorm) {
+TEST_F(ParserImplTest, TexelFormat_Rgba8Snorm) {
     auto p = parser("rgba8snorm");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -65,7 +66,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba8Uint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba8Uint) {
     auto p = parser("rgba8uint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -73,7 +74,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba8Sint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba8Sint) {
     auto p = parser("rgba8sint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -81,7 +82,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rg32Uint) {
+TEST_F(ParserImplTest, TexelFormat_Rg32Uint) {
     auto p = parser("rg32uint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -89,7 +90,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rg32Sint) {
+TEST_F(ParserImplTest, TexelFormat_Rg32Sint) {
     auto p = parser("rg32sint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -97,7 +98,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rg32Float) {
+TEST_F(ParserImplTest, TexelFormat_Rg32Float) {
     auto p = parser("rg32float");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -105,7 +106,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba16Uint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba16Uint) {
     auto p = parser("rgba16uint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -113,7 +114,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba16Sint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba16Sint) {
     auto p = parser("rgba16sint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -121,7 +122,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba16Float) {
+TEST_F(ParserImplTest, TexelFormat_Rgba16Float) {
     auto p = parser("rgba16float");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -129,7 +130,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba32Uint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba32Uint) {
     auto p = parser("rgba32uint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -137,7 +138,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba32Sint) {
+TEST_F(ParserImplTest, TexelFormat_Rgba32Sint) {
     auto p = parser("rgba32sint");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
@@ -145,7 +146,7 @@
     EXPECT_FALSE(p->has_error());
 }
 
-TEST_F(ParserImplTest, ImageStorageType_Rgba32Float) {
+TEST_F(ParserImplTest, TexelFormat_Rgba32Float) {
     auto p = parser("rgba32float");
     auto t = p->expect_texel_format("test");
     EXPECT_FALSE(t.errored);
diff --git a/src/tint/reader/wgsl/parser_impl_texture_sampler_test.cc b/src/tint/reader/wgsl/parser_impl_texture_sampler_test.cc
index 1143c52..ce31276 100644
--- a/src/tint/reader/wgsl/parser_impl_texture_sampler_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_texture_sampler_test.cc
@@ -218,7 +218,19 @@
     EXPECT_EQ(t.value, nullptr);
     EXPECT_FALSE(t.matched);
     EXPECT_TRUE(t.errored);
-    EXPECT_EQ(p->error(), "1:20: invalid format for storage texture type");
+    EXPECT_EQ(p->error(), R"(1:20: expected texel format for storage texture type
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm')");
+}
+
+TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_InvalidTypeSuggest) {
+    auto p = parser("texture_storage_1d<rg32_float, read>");
+    auto t = p->texture_and_sampler_types();
+    EXPECT_EQ(t.value, nullptr);
+    EXPECT_FALSE(t.matched);
+    EXPECT_TRUE(t.errored);
+    EXPECT_EQ(p->error(),
+              R"(1:20: expected texel format for storage texture type. Did you mean 'rg32float'?
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm')");
 }
 
 TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_InvalidAccess) {
@@ -227,7 +239,8 @@
     EXPECT_EQ(t.value, nullptr);
     EXPECT_FALSE(t.matched);
     EXPECT_TRUE(t.errored);
-    EXPECT_EQ(p->error(), "1:30: invalid value for access control");
+    EXPECT_EQ(p->error(), R"(1:30: expected access control for storage texture type. Did you mean 'read'?
+Possible values: 'read', 'read_write', 'write')");
 }
 
 TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_MissingType) {
@@ -236,7 +249,8 @@
     EXPECT_EQ(t.value, nullptr);
     EXPECT_FALSE(t.matched);
     EXPECT_TRUE(t.errored);
-    EXPECT_EQ(p->error(), "1:20: invalid format for storage texture type");
+    EXPECT_EQ(p->error(), R"(1:20: expected texel format for storage texture type
+Possible values: 'r32float', 'r32sint', 'r32uint', 'rg32float', 'rg32sint', 'rg32uint', 'rgba16float', 'rgba16sint', 'rgba16uint', 'rgba32float', 'rgba32sint', 'rgba32uint', 'rgba8sint', 'rgba8snorm', 'rgba8uint', 'rgba8unorm')");
 }
 
 TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_MissingLessThan) {
diff --git a/src/tint/reader/wgsl/parser_impl_type_decl_test.cc b/src/tint/reader/wgsl/parser_impl_type_decl_test.cc
index 0e018e0..ad8946f 100644
--- a/src/tint/reader/wgsl/parser_impl_type_decl_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_type_decl_test.cc
@@ -272,7 +272,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: expected identifier for address space");
+    ASSERT_EQ(p->error(), R"(1:5: expected address space for ptr declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingType) {
@@ -292,7 +293,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:20: expected identifier for access control");
+    ASSERT_EQ(p->error(), R"(1:20: expected access control for ptr declaration
+Possible values: 'read', 'read_write', 'write')");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingParams) {
@@ -302,7 +304,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: expected identifier for address space");
+    ASSERT_EQ(p->error(), R"(1:5: expected address space for ptr declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_BadAddressSpace) {
@@ -312,7 +315,9 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: invalid address space for ptr declaration");
+    ASSERT_EQ(p->error(),
+              R"(1:5: expected address space for ptr declaration. Did you mean 'uniform'?
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_BadAccess) {
@@ -322,7 +327,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:20: invalid value for access control");
+    ASSERT_EQ(p->error(), R"(1:20: expected access control for ptr declaration
+Possible values: 'read', 'read_write', 'write')");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Atomic) {
diff --git a/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc b/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc
index 186b364..e37a347 100644
--- a/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc
@@ -263,7 +263,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: expected identifier for address space");
+    ASSERT_EQ(p->error(), R"(1:5: expected address space for ptr declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_MissingType) {
@@ -283,7 +284,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:20: expected identifier for access control");
+    ASSERT_EQ(p->error(), R"(1:20: expected access control for ptr declaration
+Possible values: 'read', 'read_write', 'write')");
 }
 
 TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_MissingParams) {
@@ -293,7 +295,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: expected identifier for address space");
+    ASSERT_EQ(p->error(), R"(1:5: expected address space for ptr declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_BadAddressSpace) {
@@ -303,7 +306,9 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:5: invalid address space for ptr declaration");
+    ASSERT_EQ(p->error(),
+              R"(1:5: expected address space for ptr declaration. Did you mean 'uniform'?
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_BadAccess) {
@@ -313,7 +318,8 @@
     EXPECT_FALSE(t.matched);
     ASSERT_EQ(t.value, nullptr);
     ASSERT_TRUE(p->has_error());
-    ASSERT_EQ(p->error(), "1:20: invalid value for access control");
+    ASSERT_EQ(p->error(), R"(1:20: expected access control for ptr declaration
+Possible values: 'read', 'read_write', 'write')");
 }
 
 TEST_F(ParserImplTest, TypeDeclWithoutIdent_Atomic) {
diff --git a/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc b/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
index a814ea6..79574a8 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
@@ -58,8 +58,19 @@
     EXPECT_TRUE(attrs.errored);
     EXPECT_FALSE(attrs.matched);
     EXPECT_TRUE(attrs.value.IsEmpty());
-    EXPECT_EQ(p->error(), "1:10: invalid value for builtin attribute");
+    EXPECT_EQ(p->error(), R"(1:10: expected builtin
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
 }
 
+TEST_F(ParserImplTest, AttributeList_InvalidValueSuggest) {
+    auto p = parser("@builtin(instanceindex)");
+    auto attrs = p->attribute_list();
+    EXPECT_TRUE(p->has_error());
+    EXPECT_TRUE(attrs.errored);
+    EXPECT_FALSE(attrs.matched);
+    EXPECT_TRUE(attrs.value.IsEmpty());
+    EXPECT_EQ(p->error(), R"(1:10: expected builtin. Did you mean 'instance_index'?
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
+}
 }  // namespace
 }  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc b/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
index 7c52838..70af3b2 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
@@ -177,7 +177,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: expected identifier for builtin");
+    EXPECT_EQ(p->error(), R"(1:9: expected builtin
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
 }
 
 TEST_F(ParserImplTest, Attribute_Builtin_InvalidValue) {
@@ -187,7 +188,19 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: invalid value for builtin attribute");
+    EXPECT_EQ(p->error(), R"(1:9: expected builtin
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
+}
+
+TEST_F(ParserImplTest, Attribute_Builtin_InvalidValueSuggest) {
+    auto p = parser("builtin(front_face)");
+    auto attr = p->attribute();
+    EXPECT_FALSE(attr.matched);
+    EXPECT_TRUE(attr.errored);
+    EXPECT_EQ(attr.value, nullptr);
+    EXPECT_TRUE(p->has_error());
+    EXPECT_EQ(p->error(), R"(1:9: expected builtin. Did you mean 'front_facing'?
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
 }
 
 TEST_F(ParserImplTest, Attribute_Builtin_MissingInvalid) {
@@ -197,7 +210,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: expected identifier for builtin");
+    EXPECT_EQ(p->error(), R"(1:9: expected builtin
+Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_Flat) {
@@ -213,7 +227,7 @@
 
     auto* interp = var_attr->As<ast::InterpolateAttribute>();
     EXPECT_EQ(interp->type, ast::InterpolationType::kFlat);
-    EXPECT_EQ(interp->sampling, ast::InterpolationSampling::kNone);
+    EXPECT_EQ(interp->sampling, ast::InterpolationSampling::kInvalid);
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_Single_TrailingComma) {
@@ -229,7 +243,7 @@
 
     auto* interp = var_attr->As<ast::InterpolateAttribute>();
     EXPECT_EQ(interp->type, ast::InterpolationType::kFlat);
-    EXPECT_EQ(interp->sampling, ast::InterpolationSampling::kNone);
+    EXPECT_EQ(interp->sampling, ast::InterpolationSampling::kInvalid);
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_Single_DoubleTrailingComma) {
@@ -239,7 +253,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:18: expected identifier for interpolation sample name");
+    EXPECT_EQ(p->error(), R"(1:18: expected interpolation sampling
+Possible values: 'center', 'centroid', 'sample')");
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_Perspective_Center) {
@@ -333,7 +348,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:13: expected identifier for interpolation type name");
+    EXPECT_EQ(p->error(), R"(1:13: expected interpolation type
+Possible values: 'flat', 'linear', 'perspective')");
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_InvalidFirstValue) {
@@ -343,7 +359,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:13: invalid interpolation type");
+    EXPECT_EQ(p->error(), R"(1:13: expected interpolation type
+Possible values: 'flat', 'linear', 'perspective')");
 }
 
 TEST_F(ParserImplTest, Attribute_Interpolate_InvalidSecondValue) {
@@ -353,7 +370,8 @@
     EXPECT_TRUE(attr.errored);
     EXPECT_EQ(attr.value, nullptr);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:26: invalid interpolation sampling");
+    EXPECT_EQ(p->error(), R"(1:26: expected interpolation sampling. Did you mean 'sample'?
+Possible values: 'center', 'centroid', 'sample')");
 }
 
 TEST_F(ParserImplTest, Attribute_Binding) {
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 8427c6e..5cf038b 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
@@ -105,7 +105,9 @@
     EXPECT_FALSE(v.matched);
     EXPECT_TRUE(v.errored);
     EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:5: invalid address space for variable declaration");
+    EXPECT_EQ(p->error(),
+              R"(1:5: expected address space for variable declaration. Did you mean 'uniform'?
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 }  // namespace
diff --git a/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
index 9f8663d..32c1a54 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
@@ -47,11 +47,11 @@
     ParserImplTest,
     VariableQualifierTest,
     testing::Values(
-        VariableStorageData{"uniform", ast::AddressSpace::kUniform, ast::Access::kUndefined},
-        VariableStorageData{"workgroup", ast::AddressSpace::kWorkgroup, ast::Access::kUndefined},
-        VariableStorageData{"storage", ast::AddressSpace::kStorage, ast::Access::kUndefined},
-        VariableStorageData{"private", ast::AddressSpace::kPrivate, ast::Access::kUndefined},
-        VariableStorageData{"function", ast::AddressSpace::kFunction, ast::Access::kUndefined},
+        VariableStorageData{"uniform", ast::AddressSpace::kUniform, ast::Access::kInvalid},
+        VariableStorageData{"workgroup", ast::AddressSpace::kWorkgroup, ast::Access::kInvalid},
+        VariableStorageData{"storage", ast::AddressSpace::kStorage, ast::Access::kInvalid},
+        VariableStorageData{"private", ast::AddressSpace::kPrivate, ast::Access::kInvalid},
+        VariableStorageData{"function", ast::AddressSpace::kFunction, ast::Access::kInvalid},
         VariableStorageData{"storage, read", ast::AddressSpace::kStorage, ast::Access::kRead},
         VariableStorageData{"storage, write", ast::AddressSpace::kStorage, ast::Access::kWrite},
         VariableStorageData{"storage, read_write", ast::AddressSpace::kStorage,
@@ -63,7 +63,8 @@
     EXPECT_TRUE(p->has_error());
     EXPECT_TRUE(sc.errored);
     EXPECT_FALSE(sc.matched);
-    EXPECT_EQ(p->error(), "1:2: invalid address space for variable declaration");
+    EXPECT_EQ(p->error(), R"(1:2: expected address space for variable declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, VariableQualifier_Empty) {
@@ -72,7 +73,8 @@
     EXPECT_TRUE(p->has_error());
     EXPECT_TRUE(sc.errored);
     EXPECT_FALSE(sc.matched);
-    EXPECT_EQ(p->error(), "1:2: expected identifier for address space");
+    EXPECT_EQ(p->error(), R"(1:2: expected address space for variable declaration
+Possible values: 'function', 'private', 'push_constant', 'storage', 'uniform', 'workgroup')");
 }
 
 TEST_F(ParserImplTest, VariableQualifier_MissingLessThan) {
diff --git a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
index 247f340..3b83ecc 100644
--- a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
@@ -23,6 +23,17 @@
 
 // Test an empty while loop.
 TEST_F(WhileStmtTest, Empty) {
+    auto p = parser("while true { }");
+    auto wl = p->while_statement();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_FALSE(wl.errored);
+    ASSERT_TRUE(wl.matched);
+    EXPECT_TRUE(Is<ast::Expression>(wl->condition));
+    EXPECT_TRUE(wl->body->Empty());
+}
+
+// Test an empty while loop with parentheses.
+TEST_F(WhileStmtTest, EmptyWithParentheses) {
     auto p = parser("while (true) { }");
     auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -46,17 +57,6 @@
 
 // Test a while loop with complex condition.
 TEST_F(WhileStmtTest, ComplexCondition) {
-    auto p = parser("while ((a + 1 - 2) == 3) { }");
-    auto wl = p->while_statement();
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_FALSE(wl.errored);
-    ASSERT_TRUE(wl.matched);
-    EXPECT_TRUE(Is<ast::Expression>(wl->condition));
-    EXPECT_TRUE(wl->body->Empty());
-}
-
-// Test a while loop with no brackets.
-TEST_F(WhileStmtTest, NoBrackets) {
     auto p = parser("while (a + 1 - 2) == 3 { }");
     auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -66,9 +66,20 @@
     EXPECT_TRUE(wl->body->Empty());
 }
 
+// Test a while loop with complex condition, with parentheses.
+TEST_F(WhileStmtTest, ComplexConditionWithParentheses) {
+    auto p = parser("while ((a + 1 - 2) == 3) { }");
+    auto wl = p->while_statement();
+    EXPECT_FALSE(p->has_error()) << p->error();
+    EXPECT_FALSE(wl.errored);
+    ASSERT_TRUE(wl.matched);
+    EXPECT_TRUE(Is<ast::Expression>(wl->condition));
+    EXPECT_TRUE(wl->body->Empty());
+}
+
 class WhileStmtErrorTest : public ParserImplTest {
   public:
-    void TestForWithError(std::string for_str, std::string error_str) {
+    void TestWhileWithError(std::string for_str, std::string error_str) {
         auto p_for = parser(for_str);
         auto e_for = p_for->while_statement();
 
@@ -85,7 +96,7 @@
     std::string while_str = "while bool) { }";
     std::string error_str = "1:11: expected '(' for type constructor";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with missing condition is invalid.
@@ -93,7 +104,7 @@
     std::string while_str = "while () {}";
     std::string error_str = "1:8: unable to parse expression";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with missing right parenthesis is invalid.
@@ -101,7 +112,7 @@
     std::string while_str = "while (true {}";
     std::string error_str = "1:13: expected ')'";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with missing left brace is invalid.
@@ -109,7 +120,7 @@
     std::string while_str = "while (true) }";
     std::string error_str = "1:14: expected '{'";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a for loop with missing right brace is invalid.
@@ -117,7 +128,7 @@
     std::string while_str = "while (true) {";
     std::string error_str = "1:15: expected '}'";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with an invalid break condition.
@@ -125,7 +136,7 @@
     std::string while_str = "while ((0 == 1) { }";
     std::string error_str = "1:17: expected ')'";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with a break condition not matching
@@ -134,7 +145,7 @@
     std::string while_str = "while (var i: i32 = 0) { }";
     std::string error_str = "1:8: unable to parse expression";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a while loop with an invalid body.
@@ -142,7 +153,7 @@
     std::string while_str = "while (true) { let x: i32; }";
     std::string error_str = "1:26: expected '=' for 'let' declaration";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 // Test a for loop with a body not matching statements
@@ -150,7 +161,7 @@
     std::string while_str = "while (true) { fn main() {} }";
     std::string error_str = "1:16: expected '}'";
 
-    TestForWithError(while_str, error_str);
+    TestWhileWithError(while_str, error_str);
 }
 
 }  // namespace
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index 796487b..018dbfd 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -721,7 +721,7 @@
 }
 
 TEST_F(StructMemberAttributeTest, Align_Attribute_Var) {
-    GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined,
+    GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kInvalid,
               Expr(1.23_f));
 
     Structure(Source{{6, 4}}, "mystruct",
@@ -1386,16 +1386,16 @@
     ResolverAttributeValidationTest,
     InterpolateParameterTest,
     testing::Values(
-        Params{ast::InterpolationType::kPerspective, ast::InterpolationSampling::kNone, true},
+        Params{ast::InterpolationType::kPerspective, ast::InterpolationSampling::kInvalid, true},
         Params{ast::InterpolationType::kPerspective, ast::InterpolationSampling::kCenter, true},
         Params{ast::InterpolationType::kPerspective, ast::InterpolationSampling::kCentroid, true},
         Params{ast::InterpolationType::kPerspective, ast::InterpolationSampling::kSample, true},
-        Params{ast::InterpolationType::kLinear, ast::InterpolationSampling::kNone, true},
+        Params{ast::InterpolationType::kLinear, ast::InterpolationSampling::kInvalid, true},
         Params{ast::InterpolationType::kLinear, ast::InterpolationSampling::kCenter, true},
         Params{ast::InterpolationType::kLinear, ast::InterpolationSampling::kCentroid, true},
         Params{ast::InterpolationType::kLinear, ast::InterpolationSampling::kSample, true},
         // flat interpolation must not have a sampling type
-        Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kNone, true},
+        Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kInvalid, true},
         Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kCenter, false},
         Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kCentroid, false},
         Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kSample, false}));
@@ -1443,7 +1443,7 @@
                    utils::Vector{
                        Builtin(ast::BuiltinValue::kPosition),
                        Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
-                                   ast::InterpolationSampling::kNone),
+                                   ast::InterpolationSampling::kInvalid),
                    }),
          },
          ty.void_(), utils::Empty,
@@ -1467,7 +1467,7 @@
          utils::Vector{
              Builtin(ast::BuiltinValue::kPosition),
              Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
-                         ast::InterpolationSampling::kNone),
+                         ast::InterpolationSampling::kInvalid),
          });
 
     EXPECT_FALSE(r()->Resolve());
@@ -1480,7 +1480,7 @@
               utils::Vector{
                   Member("a", ty.f32(),
                          utils::Vector{Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
-                                                   ast::InterpolationSampling::kNone)}),
+                                                   ast::InterpolationSampling::kInvalid)}),
               });
 
     EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 9ddf24f..d9fde25 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -231,27 +231,29 @@
             return this;
         }
         return ZeroTypeDispatch(target_ty, [&](auto zero_to) -> ImplResult {
-            // `T` is the source type, `value` is the source value.
+            // `value` is the source value.
+            // `FROM` is the source type.
             // `TO` is the target type.
             using TO = std::decay_t<decltype(zero_to)>;
+            using FROM = T;
             if constexpr (std::is_same_v<TO, bool>) {
                 // [x -> bool]
                 return builder.create<Element<TO>>(target_ty, !IsPositiveZero(value));
-            } else if constexpr (std::is_same_v<T, bool>) {
+            } else if constexpr (std::is_same_v<FROM, bool>) {
                 // [bool -> x]
                 return builder.create<Element<TO>>(target_ty, TO(value ? 1 : 0));
             } else if (auto conv = CheckedConvert<TO>(value)) {
                 // Conversion success
                 return builder.create<Element<TO>>(target_ty, conv.Get());
                 // --- Below this point are the failure cases ---
-            } else if constexpr (IsAbstract<T>) {
+            } else if constexpr (IsAbstract<FROM>) {
                 // [abstract-numeric -> x] - materialization failure
                 std::stringstream ss;
                 ss << "value " << value << " cannot be represented as ";
                 ss << "'" << builder.FriendlyName(target_ty) << "'";
                 builder.Diagnostics().add_error(tint::diag::System::Resolver, ss.str(), source);
                 return utils::Failure;
-            } else if constexpr (IsFloatingPoint<UnwrapNumber<TO>>) {
+            } else if constexpr (IsFloatingPoint<TO>) {
                 // [x -> floating-point] - number not exactly representable
                 // https://www.w3.org/TR/WGSL/#floating-point-conversion
                 switch (conv.Failure()) {
@@ -260,8 +262,8 @@
                     case ConversionFailure::kExceedsPositiveLimit:
                         return builder.create<Element<TO>>(target_ty, TO::Inf());
                 }
-            } else {
-                // [x -> integer] - number not exactly representable
+            } else if constexpr (IsFloatingPoint<FROM>) {
+                // [floating-point -> integer] - number not exactly representable
                 // https://www.w3.org/TR/WGSL/#floating-point-conversion
                 switch (conv.Failure()) {
                     case ConversionFailure::kExceedsNegativeLimit:
@@ -269,6 +271,10 @@
                     case ConversionFailure::kExceedsPositiveLimit:
                         return builder.create<Element<TO>>(target_ty, TO::Highest());
                 }
+            } else if constexpr (IsIntegral<FROM>) {
+                // [integer -> integer] - number not exactly representable
+                // Static cast
+                return builder.create<Element<TO>>(target_ty, static_cast<TO>(value));
             }
             return nullptr;  // Expression is not constant.
         });
@@ -842,11 +848,7 @@
         return nullptr;  // Single argument is not constant.
     }
 
-    if (auto conv = Convert(ty, args[0], source)) {
-        return conv.Get();
-    }
-
-    return nullptr;
+    return Convert(ty, args[0], source);
 }
 
 ConstEval::Result ConstEval::Zero(const sem::Type* ty,
diff --git a/src/tint/resolver/const_eval_test.cc b/src/tint/resolver/const_eval_test.cc
index 8bded4c..cf3cda0 100644
--- a/src/tint/resolver/const_eval_test.cc
+++ b/src/tint/resolver/const_eval_test.cc
@@ -44,6 +44,30 @@
 template <typename T>
 const auto k3PiOver4 = T(UnwrapNumber<T>(2.356194490192344928846));
 
+/// Walks the sem::Constant @p c, accumulating all the inner-most scalar values into @p args
+void CollectScalarArgs(const sem::Constant* c, builder::ScalarArgs& args) {
+    Switch(
+        c->Type(),  //
+        [&](const sem::Bool*) { args.values.Push(c->As<bool>()); },
+        [&](const sem::I32*) { args.values.Push(c->As<i32>()); },
+        [&](const sem::U32*) { args.values.Push(c->As<u32>()); },
+        [&](const sem::F32*) { args.values.Push(c->As<f32>()); },
+        [&](const sem::F16*) { args.values.Push(c->As<f16>()); },
+        [&](Default) {
+            size_t i = 0;
+            while (auto* child = c->Index(i++)) {
+                CollectScalarArgs(child, args);
+            }
+        });
+}
+
+/// Walks the sem::Constant @p c, returning all the inner-most scalar values.
+builder::ScalarArgs ScalarArgsFrom(const sem::Constant* c) {
+    builder::ScalarArgs out;
+    CollectScalarArgs(c, out);
+    return out;
+}
+
 template <typename T>
 constexpr auto Negate(const Number<T>& v) {
     if constexpr (std::is_integral_v<T>) {
@@ -1211,283 +1235,6 @@
     EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), false);
 }
 
-TEST_F(ResolverConstEvalTest, Vec3_Convert_f32_to_i32) {
-    auto* expr = vec3<i32>(vec3<f32>(1.1_f, 2.2_f, 3.3_f));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::I32>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), 1);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), 2);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f32) {
-    auto* expr = vec3<f32>(vec3<u32>(10_u, 20_u, 30_u));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::F32>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 10.f);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), 20.f);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_f16_to_i32) {
-    Enable(ast::Extension::kF16);
-
-    auto* expr = vec3<i32>(vec3<f16>(1.1_h, 2.2_h, 3.3_h));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::I32>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), 1_i);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), 2_i);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3_i);
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f16) {
-    Enable(ast::Extension::kF16);
-
-    auto* expr = vec3<f16>(vec3<u32>(10_u, 20_u, 30_u));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::F16>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 10.f);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), 20.f);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_i32) {
-    auto* expr = vec3<i32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::I32>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), i32::Highest());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), i32::Lowest());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), i32::Highest());
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_u32) {
-    auto* expr = vec3<u32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::U32>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_TRUE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), u32::Highest());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), u32::Lowest());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), u32::Highest());
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_f16) {
-    Enable(ast::Extension::kF16);
-
-    auto* expr = vec3<f16>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    constexpr auto kInfinity = std::numeric_limits<double>::infinity();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::F16>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), kInfinity);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), -kInfinity);
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), kInfinity);
-}
-
-TEST_F(ResolverConstEvalTest, Vec3_Convert_Small_f32_to_f16) {
-    Enable(ast::Extension::kF16);
-
-    auto* expr = vec3<f16>(vec3<f32>(1e-20_f, -2e-30_f, 3e-40_f));
-    WrapInFunction(expr);
-
-    EXPECT_TRUE(r()->Resolve()) << r()->error();
-
-    auto* sem = Sem().Get(expr);
-    ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<sem::Vector>();
-    ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<sem::F16>());
-    EXPECT_EQ(vec->Width(), 3u);
-    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
-    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
-    EXPECT_TRUE(sem->ConstantValue()->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->AllZero());
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 0.0);
-    EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(0)->As<AFloat>().value));
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
-    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), -0.0);
-    EXPECT_TRUE(std::signbit(sem->ConstantValue()->Index(1)->As<AFloat>().value));
-
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 0.0);
-    EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(2)->As<AFloat>().value));
-}
-
 TEST_F(ResolverConstEvalTest, Mat2x3_ZeroInit_f32) {
     auto* expr = mat2x3<f32>();
     WrapInFunction(expr);
@@ -2475,6 +2222,519 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+// Conversion
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace conv {
+
+using Scalar = std::variant<  //
+    builder::Value<AInt>,
+    builder::Value<AFloat>,
+    builder::Value<u32>,
+    builder::Value<i32>,
+    builder::Value<f32>,
+    builder::Value<f16>,
+    builder::Value<bool>>;
+
+static std::ostream& operator<<(std::ostream& o, const Scalar& scalar) {
+    std::visit(
+        [&](auto&& v) {
+            using ValueType = std::decay_t<decltype(v)>;
+            o << ValueType::DataType::Name() << "(";
+            for (auto& a : v.args.values) {
+                o << std::get<typename ValueType::ElementType>(a);
+                if (&a != &v.args.values.Back()) {
+                    o << ", ";
+                }
+            }
+            o << ")";
+        },
+        scalar);
+    return o;
+}
+
+enum class Kind {
+    kScalar,
+    kVector,
+};
+
+static std::ostream& operator<<(std::ostream& o, const Kind& k) {
+    switch (k) {
+        case Kind::kScalar:
+            return o << "scalar";
+        case Kind::kVector:
+            return o << "vector";
+    }
+    return o << "<unknown>";
+}
+
+struct Case {
+    Scalar input;
+    Scalar expected;
+    builder::CreatePtrs type;
+    bool unrepresentable = false;
+};
+
+static std::ostream& operator<<(std::ostream& o, const Case& c) {
+    if (c.unrepresentable) {
+        o << "[unrepresentable] input: " << c.input;
+    } else {
+        o << "input: " << c.input << ", expected: " << c.expected;
+    }
+    return o << ", type: " << c.type;
+}
+
+template <typename TO, typename FROM>
+Case Success(FROM input, TO expected) {
+    return {builder::Val(input), builder::Val(expected), builder::CreatePtrsFor<TO>()};
+}
+
+template <typename TO, typename FROM>
+Case Unrepresentable(FROM input) {
+    return {builder::Val(input), builder::Val(0_i), builder::CreatePtrsFor<TO>(),
+            /* unrepresentable */ true};
+}
+
+using ResolverConstEvalConvTest = ResolverTestWithParam<std::tuple<Kind, Case>>;
+
+TEST_P(ResolverConstEvalConvTest, Test) {
+    const auto& kind = std::get<0>(GetParam());
+    const auto& input = std::get<1>(GetParam()).input;
+    const auto& expected = std::get<1>(GetParam()).expected;
+    const auto& type = std::get<1>(GetParam()).type;
+    const auto unrepresentable = std::get<1>(GetParam()).unrepresentable;
+
+    auto* input_val = std::visit([&](auto val) { return val.Expr(*this); }, input);
+    auto* expr = Construct(type.ast(*this), input_val);
+    if (kind == Kind::kVector) {
+        expr = Construct(ty.vec(nullptr, 3), expr);
+    }
+    WrapInFunction(expr);
+
+    auto* target_sem_ty = type.sem(*this);
+    if (kind == Kind::kVector) {
+        target_sem_ty = create<sem::Vector>(target_sem_ty, 3u);
+    }
+
+    if (unrepresentable) {
+        ASSERT_FALSE(r()->Resolve());
+        EXPECT_THAT(r()->error(), testing::HasSubstr("cannot be represented as"));
+    } else {
+        EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+        auto* sem = Sem().Get(expr);
+        ASSERT_NE(sem, nullptr);
+        EXPECT_TYPE(sem->Type(), target_sem_ty);
+        ASSERT_NE(sem->ConstantValue(), nullptr);
+        EXPECT_TYPE(sem->ConstantValue()->Type(), target_sem_ty);
+
+        auto expected_values = std::visit([&](auto&& val) { return val.args; }, expected);
+        if (kind == Kind::kVector) {
+            expected_values.values.Push(expected_values.values[0]);
+            expected_values.values.Push(expected_values.values[0]);
+        }
+        auto got_values = ScalarArgsFrom(sem->ConstantValue());
+        EXPECT_EQ(expected_values, got_values);
+    }
+}
+INSTANTIATE_TEST_SUITE_P(ScalarAndVector,
+                         ResolverConstEvalConvTest,
+                         testing::Combine(testing::Values(Kind::kScalar, Kind::kVector),
+                                          testing::ValuesIn({
+                                              // TODO(crbug.com/tint/1502): Add f16 tests
+                                              // i32 -> u32
+                                              Success(0_i, 0_u),
+                                              Success(1_i, 1_u),
+                                              Success(-1_i, 0xffffffff_u),
+                                              Success(2_i, 2_u),
+                                              Success(-2_i, 0xfffffffe_u),
+                                              // i32 -> f32
+                                              Success(0_i, 0_f),
+                                              Success(1_i, 1_f),
+                                              Success(-1_i, -1_f),
+                                              Success(2_i, 2_f),
+                                              Success(-2_i, -2_f),
+                                              // i32 -> bool
+                                              Success(0_i, false),
+                                              Success(1_i, true),
+                                              Success(-1_i, true),
+                                              Success(2_i, true),
+                                              Success(-2_i, true),
+                                              // u32 -> i32
+                                              Success(0_u, 0_i),
+                                              Success(1_u, 1_i),
+                                              Success(0xffffffff_u, -1_i),
+                                              Success(2_u, 2_i),
+                                              Success(0xfffffffe_u, -2_i),
+                                              // u32 -> f32
+                                              Success(0_u, 0_f),
+                                              Success(1_u, 1_f),
+                                              Success(2_u, 2_f),
+                                              Success(0xffffffff_u, 0xffffffff_f),
+                                              // u32 -> bool
+                                              Success(0_u, false),
+                                              Success(1_u, true),
+                                              Success(2_u, true),
+                                              Success(0xffffffff_u, true),
+                                              // f32 -> i32
+                                              Success(0_f, 0_i),
+                                              Success(1_f, 1_i),
+                                              Success(2_f, 2_i),
+                                              Success(1e20_f, i32::Highest()),
+                                              Success(-1e20_f, i32::Lowest()),
+                                              // f32 -> u32
+                                              Success(0_f, 0_i),
+                                              Success(1_f, 1_i),
+                                              Success(-1_f, u32::Lowest()),
+                                              Success(2_f, 2_i),
+                                              Success(1e20_f, u32::Highest()),
+                                              Success(-1e20_f, u32::Lowest()),
+                                              // f32 -> bool
+                                              Success(0_f, false),
+                                              Success(1_f, true),
+                                              Success(-1_f, true),
+                                              Success(2_f, true),
+                                              Success(1e20_f, true),
+                                              Success(-1e20_f, true),
+                                              // abstract-int -> i32
+                                              Success(0_a, 0_i),
+                                              Success(1_a, 1_i),
+                                              Success(-1_a, -1_i),
+                                              Success(0x7fffffff_a, i32::Highest()),
+                                              Success(-0x80000000_a, i32::Lowest()),
+                                              Unrepresentable<i32>(0x80000000_a),
+                                              // abstract-int -> u32
+                                              Success(0_a, 0_u),
+                                              Success(1_a, 1_u),
+                                              Success(0xffffffff_a, 0xffffffff_u),
+                                              Unrepresentable<u32>(0x100000000_a),
+                                              Unrepresentable<u32>(-1_a),
+                                              // abstract-int -> f32
+                                              Success(0_a, 0_f),
+                                              Success(1_a, 1_f),
+                                              Success(0xffffffff_a, 0xffffffff_f),
+                                              Success(0x100000000_a, 0x100000000_f),
+                                              Success(-0x100000000_a, -0x100000000_f),
+                                              Success(0x7fffffffffffffff_a, 0x7fffffffffffffff_f),
+                                              Success(-0x7fffffffffffffff_a, -0x7fffffffffffffff_f),
+                                              // abstract-int -> bool
+                                              Success(0_a, false),
+                                              Success(1_a, true),
+                                              Success(0xffffffff_a, true),
+                                              Success(0x100000000_a, true),
+                                              Success(-0x100000000_a, true),
+                                              Success(0x7fffffffffffffff_a, true),
+                                              Success(-0x7fffffffffffffff_a, true),
+                                              // abstract-float -> i32
+                                              Success(0.0_a, 0_i),
+                                              Success(1.0_a, 1_i),
+                                              Success(-1.0_a, -1_i),
+                                              Success(AFloat(0x7fffffff), i32::Highest()),
+                                              Success(-AFloat(0x80000000), i32::Lowest()),
+                                              Unrepresentable<i32>(0x80000000_a),
+                                              // abstract-float -> u32
+                                              Success(0.0_a, 0_u),
+                                              Success(1.0_a, 1_u),
+                                              Success(AFloat(0xffffffff), 0xffffffff_u),
+                                              Unrepresentable<u32>(AFloat(0x100000000)),
+                                              Unrepresentable<u32>(AFloat(-1)),
+                                              // abstract-float -> f32
+                                              Success(0.0_a, 0_f),
+                                              Success(1.0_a, 1_f),
+                                              Success(AFloat(0xffffffff), 0xffffffff_f),
+                                              Success(AFloat(0x100000000), 0x100000000_f),
+                                              Success(-AFloat(0x100000000), -0x100000000_f),
+                                              Unrepresentable<f32>(1e40_a),
+                                              Unrepresentable<f32>(-1e40_a),
+                                              // abstract-float -> bool
+                                              Success(0.0_a, false),
+                                              Success(1.0_a, true),
+                                              Success(AFloat(0xffffffff), true),
+                                              Success(AFloat(0x100000000), true),
+                                              Success(-AFloat(0x100000000), true),
+                                              Success(1e40_a, true),
+                                              Success(-1e40_a, true),
+                                          })));
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_f32_to_i32) {
+    auto* expr = vec3<i32>(vec3<f32>(1.1_f, 2.2_f, 3.3_f));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::I32>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), 1);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), 2);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f32) {
+    auto* expr = vec3<f32>(vec3<u32>(10_u, 20_u, 30_u));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::F32>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 10.f);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), 20.f);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_f16_to_i32) {
+    Enable(ast::Extension::kF16);
+
+    auto* expr = vec3<i32>(vec3<f16>(1.1_h, 2.2_h, 3.3_h));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    EXPECT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::I32>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), 1_i);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), 2_i);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3_i);
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f16) {
+    Enable(ast::Extension::kF16);
+
+    auto* expr = vec3<f16>(vec3<u32>(10_u, 20_u, 30_u));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    EXPECT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::F16>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 10.f);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), 20.f);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_i32) {
+    auto* expr = vec3<i32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::I32>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), i32::Highest());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), i32::Lowest());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), i32::Highest());
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_u32) {
+    auto* expr = vec3<u32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::U32>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_TRUE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AInt>(), u32::Highest());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AInt>(), u32::Lowest());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), u32::Highest());
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_f16) {
+    Enable(ast::Extension::kF16);
+
+    auto* expr = vec3<f16>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    constexpr auto kInfinity = std::numeric_limits<double>::infinity();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::F16>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), kInfinity);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), -kInfinity);
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), kInfinity);
+}
+
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Small_f32_to_f16) {
+    Enable(ast::Extension::kF16);
+
+    auto* expr = vec3<f16>(vec3<f32>(1e-20_f, -2e-30_f, 3e-40_f));
+    WrapInFunction(expr);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+    auto* sem = Sem().Get(expr);
+    ASSERT_NE(sem, nullptr);
+    auto* vec = sem->Type()->As<sem::Vector>();
+    ASSERT_NE(vec, nullptr);
+    EXPECT_TRUE(vec->type()->Is<sem::F16>());
+    EXPECT_EQ(vec->Width(), 3u);
+    EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
+    EXPECT_FALSE(sem->ConstantValue()->AllEqual());
+    EXPECT_TRUE(sem->ConstantValue()->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->AllZero());
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(0)->As<AFloat>(), 0.0);
+    EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(0)->As<AFloat>().value));
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
+    EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(1)->As<AFloat>(), -0.0);
+    EXPECT_TRUE(std::signbit(sem->ConstantValue()->Index(1)->As<AFloat>().value));
+
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
+    EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 0.0);
+    EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(2)->As<AFloat>().value));
+}
+
+}  // namespace conv
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
 // Indexing
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -3020,12 +3280,14 @@
             using T = typename std::decay_t<decltype(expected)>::ElementType;
 
             auto* input_expr = std::visit([&](auto&& value) { return value.Expr(*this); }, c.input);
-            auto* expected_expr = create<ast::UnaryOpExpression>(op, input_expr);
-            GlobalConst("C", expected_expr);
+            auto* expr = create<ast::UnaryOpExpression>(op, input_expr);
 
-            EXPECT_TRUE(r()->Resolve()) << r()->error();
+            GlobalConst("C", expr);
+            auto* expected_expr = expected.Expr(*this);
+            GlobalConst("E", expected_expr);
+            ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-            auto* sem = Sem().Get(expected_expr);
+            auto* sem = Sem().Get(expr);
             const sem::Constant* value = sem->ConstantValue();
             ASSERT_NE(value, nullptr);
             EXPECT_TYPE(value->Type(), sem->Type());
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index 0eaaa37..a82f9e8 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -1186,7 +1186,7 @@
         for (auto& p : match.parameters) {
             params.Push(builder.create<sem::Parameter>(
                 nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone,
-                ast::Access::kUndefined, p.usage));
+                ast::Access::kInvalid, p.usage));
         }
         sem::PipelineStageSet supported_stages;
         if (match.overload->flags.Contains(OverloadFlag::kSupportsVertexPipeline)) {
@@ -1384,7 +1384,7 @@
         for (auto& p : match.parameters) {
             params.Push(builder.create<sem::Parameter>(
                 nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone,
-                ast::Access::kUndefined, p.usage));
+                ast::Access::kInvalid, p.usage));
         }
         auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
                                                         : sem::EvaluationStage::kRuntime;
@@ -1397,9 +1397,9 @@
 
     // Conversion.
     auto* target = utils::GetOrCreate(converters, match, [&]() {
-        auto param = builder.create<sem::Parameter>(
-            nullptr, 0u, match.parameters[0].type, ast::AddressSpace::kNone,
-            ast::Access::kUndefined, match.parameters[0].usage);
+        auto param = builder.create<sem::Parameter>(nullptr, 0u, match.parameters[0].type,
+                                                    ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                                    match.parameters[0].usage);
         auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
                                                         : sem::EvaluationStage::kRuntime;
         return builder.create<sem::TypeConversion>(match.return_type, param, eval_stage);
@@ -1643,7 +1643,13 @@
 
     auto earliest_eval_stage = sem::EvaluationStage::kConstant;
 
-    ss << intrinsic_name << "(";
+    ss << intrinsic_name;
+    if (overload->flags.Contains(OverloadFlag::kIsConverter) && overload->template_types) {
+        ss << "<";
+        ss << overload->template_types[0].name;
+        ss << ">";
+    }
+    ss << "(";
     for (size_t p = 0; p < overload->num_parameters; p++) {
         auto& parameter = overload->parameters[p];
         if (p > 0) {
diff --git a/src/tint/resolver/intrinsic_table.inl b/src/tint/resolver/intrinsic_table.inl
index 67cb23f..426b78b 100644
--- a/src/tint/resolver/intrinsic_table.inl
+++ b/src/tint/resolver/intrinsic_table.inl
@@ -1550,8 +1550,8 @@
   return "__atomic_compare_exchange_result<" + T + ">";
 }
 
-/// TypeMatcher for 'match abstract_or_scalar'
-class AbstractOrScalar : public TypeMatcher {
+/// TypeMatcher for 'match scalar'
+class Scalar : public TypeMatcher {
  public:
   /// Checks whether the given type matches the matcher rules, and returns the
   /// expected, canonicalized type on success.
@@ -1566,7 +1566,7 @@
   std::string String(MatchState* state) const override;
 };
 
-const sem::Type* AbstractOrScalar::Match(MatchState& state, const sem::Type* ty) const {
+const sem::Type* Scalar::Match(MatchState& state, const sem::Type* ty) const {
   if (match_ia(state, ty)) {
     return build_ia(state);
   }
@@ -1591,7 +1591,7 @@
   return nullptr;
 }
 
-std::string AbstractOrScalar::String(MatchState*) const {
+std::string Scalar::String(MatchState*) const {
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
@@ -1599,8 +1599,8 @@
   return ss.str();
 }
 
-/// TypeMatcher for 'match scalar'
-class Scalar : public TypeMatcher {
+/// TypeMatcher for 'match concrete_scalar'
+class ConcreteScalar : public TypeMatcher {
  public:
   /// Checks whether the given type matches the matcher rules, and returns the
   /// expected, canonicalized type on success.
@@ -1615,7 +1615,7 @@
   std::string String(MatchState* state) const override;
 };
 
-const sem::Type* Scalar::Match(MatchState& state, const sem::Type* ty) const {
+const sem::Type* ConcreteScalar::Match(MatchState& state, const sem::Type* ty) const {
   if (match_i32(state, ty)) {
     return build_i32(state);
   }
@@ -1634,7 +1634,7 @@
   return nullptr;
 }
 
-std::string Scalar::String(MatchState*) const {
+std::string ConcreteScalar::String(MatchState*) const {
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
@@ -1659,6 +1659,12 @@
 };
 
 const sem::Type* ScalarNoF32::Match(MatchState& state, const sem::Type* ty) const {
+  if (match_ia(state, ty)) {
+    return build_ia(state);
+  }
+  if (match_fa(state, ty)) {
+    return build_fa(state);
+  }
   if (match_i32(state, ty)) {
     return build_i32(state);
   }
@@ -1678,7 +1684,7 @@
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
-  ss << I32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
+  ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << I32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
   return ss.str();
 }
 
@@ -1699,6 +1705,12 @@
 };
 
 const sem::Type* ScalarNoF16::Match(MatchState& state, const sem::Type* ty) const {
+  if (match_ia(state, ty)) {
+    return build_ia(state);
+  }
+  if (match_fa(state, ty)) {
+    return build_fa(state);
+  }
   if (match_i32(state, ty)) {
     return build_i32(state);
   }
@@ -1718,7 +1730,7 @@
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
-  ss << F32().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
+  ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << F32().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
   return ss.str();
 }
 
@@ -1739,6 +1751,12 @@
 };
 
 const sem::Type* ScalarNoI32::Match(MatchState& state, const sem::Type* ty) const {
+  if (match_ia(state, ty)) {
+    return build_ia(state);
+  }
+  if (match_fa(state, ty)) {
+    return build_fa(state);
+  }
   if (match_u32(state, ty)) {
     return build_u32(state);
   }
@@ -1758,7 +1776,7 @@
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
-  ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
+  ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
   return ss.str();
 }
 
@@ -1779,6 +1797,12 @@
 };
 
 const sem::Type* ScalarNoU32::Match(MatchState& state, const sem::Type* ty) const {
+  if (match_ia(state, ty)) {
+    return build_ia(state);
+  }
+  if (match_fa(state, ty)) {
+    return build_fa(state);
+  }
   if (match_i32(state, ty)) {
     return build_i32(state);
   }
@@ -1798,7 +1822,7 @@
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
-  ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << Bool().String(nullptr);
+  ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << Bool().String(nullptr);
   return ss.str();
 }
 
@@ -1819,6 +1843,12 @@
 };
 
 const sem::Type* ScalarNoBool::Match(MatchState& state, const sem::Type* ty) const {
+  if (match_ia(state, ty)) {
+    return build_ia(state);
+  }
+  if (match_fa(state, ty)) {
+    return build_fa(state);
+  }
   if (match_i32(state, ty)) {
     return build_i32(state);
   }
@@ -1838,7 +1868,7 @@
   std::stringstream ss;
   // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
   // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
-  ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
+  ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
   return ss.str();
 }
 
@@ -2580,8 +2610,8 @@
   FrexpResult FrexpResult_;
   FrexpResultVec FrexpResultVec_;
   AtomicCompareExchangeResult AtomicCompareExchangeResult_;
-  AbstractOrScalar AbstractOrScalar_;
   Scalar Scalar_;
+  ConcreteScalar ConcreteScalar_;
   ScalarNoF32 ScalarNoF32_;
   ScalarNoF16 ScalarNoF16_;
   ScalarNoI32 ScalarNoI32_;
@@ -2666,8 +2696,8 @@
     /* [47] */ &FrexpResult_,
     /* [48] */ &FrexpResultVec_,
     /* [49] */ &AtomicCompareExchangeResult_,
-    /* [50] */ &AbstractOrScalar_,
-    /* [51] */ &Scalar_,
+    /* [50] */ &Scalar_,
+    /* [51] */ &ConcreteScalar_,
     /* [52] */ &ScalarNoF32_,
     /* [53] */ &ScalarNoF16_,
     /* [54] */ &ScalarNoI32_,
@@ -14348,9 +14378,9 @@
   },
   {
     /* [67] */
-    /* fn select<T : abstract_or_scalar>(T, T, bool) -> T */
-    /* fn select<T : abstract_or_scalar, N : num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T> */
-    /* fn select<N : num, T : abstract_or_scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> */
+    /* fn select<T : scalar>(T, T, bool) -> T */
+    /* 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[276],
   },
@@ -14876,15 +14906,15 @@
   },
   {
     /* [10] */
-    /* op ==<T : abstract_or_scalar>(T, T) -> bool */
-    /* op ==<T : abstract_or_scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
+    /* 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[408],
   },
   {
     /* [11] */
-    /* op !=<T : abstract_or_scalar>(T, T) -> bool */
-    /* op !=<T : abstract_or_scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
+    /* 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[394],
   },
@@ -14995,10 +15025,10 @@
   },
   {
     /* [5] */
-    /* ctor vec2<T : scalar>() -> vec2<T> */
-    /* ctor vec2<T : scalar>(vec2<T>) -> vec2<T> */
-    /* ctor vec2<T : abstract_or_scalar>(T) -> vec2<T> */
-    /* ctor vec2<T : abstract_or_scalar>(x: T, y: T) -> vec2<T> */
+    /* ctor vec2<T : concrete_scalar>() -> vec2<T> */
+    /* ctor vec2<T : concrete_scalar>(vec2<T>) -> vec2<T> */
+    /* ctor vec2<T : scalar>(T) -> vec2<T> */
+    /* ctor vec2<T : scalar>(x: T, y: T) -> vec2<T> */
     /* conv vec2<T : f32, U : scalar_no_f32>(vec2<U>) -> vec2<f32> */
     /* conv vec2<T : f16, U : scalar_no_f16>(vec2<U>) -> vec2<f16> */
     /* conv vec2<T : i32, U : scalar_no_i32>(vec2<U>) -> vec2<i32> */
@@ -15009,12 +15039,12 @@
   },
   {
     /* [6] */
-    /* ctor vec3<T : scalar>() -> vec3<T> */
-    /* ctor vec3<T : scalar>(vec3<T>) -> vec3<T> */
-    /* ctor vec3<T : abstract_or_scalar>(T) -> vec3<T> */
-    /* ctor vec3<T : abstract_or_scalar>(x: T, y: T, z: T) -> vec3<T> */
-    /* ctor vec3<T : abstract_or_scalar>(xy: vec2<T>, z: T) -> vec3<T> */
-    /* ctor vec3<T : abstract_or_scalar>(x: T, yz: vec2<T>) -> vec3<T> */
+    /* ctor vec3<T : concrete_scalar>() -> vec3<T> */
+    /* ctor vec3<T : concrete_scalar>(vec3<T>) -> vec3<T> */
+    /* ctor vec3<T : scalar>(T) -> vec3<T> */
+    /* ctor vec3<T : scalar>(x: T, y: T, z: T) -> vec3<T> */
+    /* ctor vec3<T : scalar>(xy: vec2<T>, z: T) -> vec3<T> */
+    /* ctor vec3<T : scalar>(x: T, yz: vec2<T>) -> vec3<T> */
     /* conv vec3<T : f32, U : scalar_no_f32>(vec3<U>) -> vec3<f32> */
     /* conv vec3<T : f16, U : scalar_no_f16>(vec3<U>) -> vec3<f16> */
     /* conv vec3<T : i32, U : scalar_no_i32>(vec3<U>) -> vec3<i32> */
@@ -15025,16 +15055,16 @@
   },
   {
     /* [7] */
-    /* ctor vec4<T : scalar>() -> vec4<T> */
-    /* ctor vec4<T : scalar>(vec4<T>) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(T) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(x: T, y: T, z: T, w: T) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(xyz: vec3<T>, w: T) -> vec4<T> */
-    /* ctor vec4<T : abstract_or_scalar>(x: T, zyw: vec3<T>) -> vec4<T> */
+    /* ctor vec4<T : concrete_scalar>() -> vec4<T> */
+    /* ctor vec4<T : concrete_scalar>(vec4<T>) -> vec4<T> */
+    /* ctor vec4<T : scalar>(T) -> vec4<T> */
+    /* ctor vec4<T : scalar>(x: T, y: T, z: T, w: T) -> vec4<T> */
+    /* ctor vec4<T : scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T> */
+    /* ctor vec4<T : scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T> */
+    /* ctor vec4<T : scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T> */
+    /* ctor vec4<T : scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T> */
+    /* ctor vec4<T : scalar>(xyz: vec3<T>, w: T) -> vec4<T> */
+    /* ctor vec4<T : scalar>(x: T, zyw: vec3<T>) -> vec4<T> */
     /* conv vec4<T : f32, U : scalar_no_f32>(vec4<U>) -> vec4<f32> */
     /* conv vec4<T : f16, U : scalar_no_f16>(vec4<U>) -> vec4<f16> */
     /* conv vec4<T : i32, U : scalar_no_i32>(vec4<U>) -> vec4<i32> */
diff --git a/src/tint/resolver/intrinsic_table.inl.tmpl b/src/tint/resolver/intrinsic_table.inl.tmpl
index fb95eae..7b69df0 100644
--- a/src/tint/resolver/intrinsic_table.inl.tmpl
+++ b/src/tint/resolver/intrinsic_table.inl.tmpl
@@ -1,6 +1,6 @@
 {{- /*
 --------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate builtin_table.inl
+Template file for use with tools/src/cmd/gen to generate intrinsic_table.inl
 Used by BuiltinTable.cc for builtin overload resolution.
 
 To update the generated file, run:
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index 34cec07..57a6731 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -793,11 +793,11 @@
   vec3() -> vec3<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
-  vec3(vec3<U>) -> vec3<f32>  where: T is f32, U is i32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<f16>  where: T is f16, U is f32, i32, u32 or bool
-  vec3(vec3<U>) -> vec3<i32>  where: T is i32, U is f32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<u32>  where: T is u32, U is f32, f16, i32 or bool
-  vec3(vec3<U>) -> vec3<bool>  where: T is bool, U is f32, f16, i32 or u32
+  vec3<T>(vec3<U>) -> vec3<f32>  where: T is f32, U is abstract-int, abstract-float, i32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<f16>  where: T is f16, U is abstract-int, abstract-float, f32, i32, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<i32>  where: T is i32, U is abstract-int, abstract-float, f32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<u32>  where: T is u32, U is abstract-int, abstract-float, f32, f16, i32 or bool
+  vec3<T>(vec3<U>) -> vec3<bool>  where: T is bool, U is abstract-int, abstract-float, f32, f16, i32 or u32
 )");
 }
 
@@ -819,11 +819,11 @@
   vec3() -> vec3<T>  where: T is f32, f16, i32, u32 or bool
 
 5 candidate conversions:
-  vec3(vec3<U>) -> vec3<f32>  where: T is f32, U is i32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<f16>  where: T is f16, U is f32, i32, u32 or bool
-  vec3(vec3<U>) -> vec3<i32>  where: T is i32, U is f32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<u32>  where: T is u32, U is f32, f16, i32 or bool
-  vec3(vec3<U>) -> vec3<bool>  where: T is bool, U is f32, f16, i32 or u32
+  vec3<T>(vec3<U>) -> vec3<f32>  where: T is f32, U is abstract-int, abstract-float, i32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<f16>  where: T is f16, U is abstract-int, abstract-float, f32, i32, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<i32>  where: T is i32, U is abstract-int, abstract-float, f32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<u32>  where: T is u32, U is abstract-int, abstract-float, f32, f16, i32 or bool
+  vec3<T>(vec3<U>) -> vec3<bool>  where: T is bool, U is abstract-int, abstract-float, f32, f16, i32 or u32
 )");
 }
 
@@ -875,11 +875,11 @@
   vec3(x: T, y: T, z: T) -> vec3<T>  where: T is abstract-int, abstract-float, f32, f16, i32, u32 or bool
 
 5 candidate conversions:
-  vec3(vec3<U>) -> vec3<f32>  where: T is f32, U is i32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<f16>  where: T is f16, U is f32, i32, u32 or bool
-  vec3(vec3<U>) -> vec3<i32>  where: T is i32, U is f32, f16, u32 or bool
-  vec3(vec3<U>) -> vec3<u32>  where: T is u32, U is f32, f16, i32 or bool
-  vec3(vec3<U>) -> vec3<bool>  where: T is bool, U is f32, f16, i32 or u32
+  vec3<T>(vec3<U>) -> vec3<f32>  where: T is f32, U is abstract-int, abstract-float, i32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<f16>  where: T is f16, U is abstract-int, abstract-float, f32, i32, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<i32>  where: T is i32, U is abstract-int, abstract-float, f32, f16, u32 or bool
+  vec3<T>(vec3<U>) -> vec3<u32>  where: T is u32, U is abstract-int, abstract-float, f32, f16, i32 or bool
+  vec3<T>(vec3<U>) -> vec3<bool>  where: T is bool, U is abstract-int, abstract-float, f32, f16, i32 or u32
 )");
 }
 
@@ -904,7 +904,7 @@
     ASSERT_NE(result.target, nullptr);
     EXPECT_EQ(result.target->ReturnType(), i32);
     EXPECT_EQ(result.target->Parameters().Length(), 1u);
-    EXPECT_EQ(result.target->Parameters()[0]->Type(), i32);
+    EXPECT_EQ(result.target->Parameters()[0]->Type(), ai);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 4d31d70..0fe6691 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -251,7 +251,7 @@
         [&](const ast::Pointer* t) -> sem::Pointer* {
             if (auto* el = Type(t->type)) {
                 auto access = t->access;
-                if (access == ast::kUndefined) {
+                if (access == ast::Access::kInvalid) {
                     access = DefaultAccessForAddressSpace(t->address_space);
                 }
                 return builder_->create<sem::Pointer>(el, t->address_space, access);
@@ -386,13 +386,12 @@
     sem::Variable* sem = nullptr;
     if (is_global) {
         sem = builder_->create<sem::GlobalVariable>(
-            v, ty, sem::EvaluationStage::kRuntime, ast::AddressSpace::kNone,
-            ast::Access::kUndefined, /* constant_value */ nullptr, sem::BindingPoint{},
-            std::nullopt);
+            v, ty, sem::EvaluationStage::kRuntime, ast::AddressSpace::kNone, ast::Access::kInvalid,
+            /* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
     } else {
         sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime,
-                                                   ast::AddressSpace::kNone,
-                                                   ast::Access::kUndefined, current_statement_,
+                                                   ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                                   current_statement_,
                                                    /* constant_value */ nullptr);
     }
 
@@ -442,7 +441,7 @@
     }
 
     auto* sem = builder_->create<sem::GlobalVariable>(
-        v, ty, sem::EvaluationStage::kOverride, ast::AddressSpace::kNone, ast::Access::kUndefined,
+        v, ty, sem::EvaluationStage::kOverride, ast::AddressSpace::kNone, ast::Access::kInvalid,
         /* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
     sem->SetConstructor(rhs);
 
@@ -527,10 +526,10 @@
 
     auto* sem = is_global ? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
                                 c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone,
-                                ast::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt))
+                                ast::Access::kInvalid, value, sem::BindingPoint{}, std::nullopt))
                           : static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
                                 c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone,
-                                ast::Access::kUndefined, current_statement_, value));
+                                ast::Access::kInvalid, current_statement_, value));
 
     sem->SetConstructor(rhs);
     builder_->Sem().Add(c, sem);
@@ -589,7 +588,7 @@
     }
 
     auto access = var->declared_access;
-    if (access == ast::Access::kUndefined) {
+    if (access == ast::Access::kInvalid) {
         access = DefaultAccessForAddressSpace(address_space);
     }
 
@@ -753,9 +752,9 @@
         location = c->As<uint32_t>();
     }
 
-    auto* sem = builder_->create<sem::Parameter>(
-        param, index, ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
-        sem::ParameterUsage::kNone, binding_point, location);
+    auto* sem = builder_->create<sem::Parameter>(param, index, ty, ast::AddressSpace::kNone,
+                                                 ast::Access::kInvalid, sem::ParameterUsage::kNone,
+                                                 binding_point, location);
     builder_->Sem().Add(param, sem);
     return sem;
 }
@@ -1789,7 +1788,7 @@
                                 static_cast<uint32_t>(i),  // index
                                 arr->ElemType(),           // type
                                 ast::AddressSpace::kNone,  // address_space
-                                ast::Access::kUndefined);
+                                ast::Access::kInvalid);
                         });
                         return builder_->create<sem::TypeConstructor>(arr, std::move(params),
                                                                       args_stage);
@@ -1818,7 +1817,7 @@
                                 static_cast<uint32_t>(i),   // index
                                 str->Members()[i]->Type(),  // type
                                 ast::AddressSpace::kNone,   // address_space
-                                ast::Access::kUndefined);   // access
+                                ast::Access::kInvalid);     // access
                         }
                         return builder_->create<sem::TypeConstructor>(str, std::move(params),
                                                                       args_stage);
diff --git a/src/tint/resolver/resolver_test_helper.h b/src/tint/resolver/resolver_test_helper.h
index 501cd0f..923f3ff 100644
--- a/src/tint/resolver/resolver_test_helper.h
+++ b/src/tint/resolver/resolver_test_helper.h
@@ -17,6 +17,7 @@
 
 #include <functional>
 #include <memory>
+#include <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -174,13 +175,15 @@
 struct ptr {};
 
 /// Type used to accept scalars as arguments. Can be either a single value that gets splatted for
-/// composite types, or all values requried by the composite type.
+/// composite types, or all values required by the composite type.
 struct ScalarArgs {
     /// Constructor
+    ScalarArgs() = default;
+
+    /// Constructor
     /// @param single_value single value to initialize with
     template <typename T>
-    ScalarArgs(T single_value)  // NOLINT: implicit on purpose
-        : values(utils::Vector<Storage, 1>{single_value}) {}
+    explicit ScalarArgs(T single_value) : values(utils::Vector<Storage, 1>{single_value}) {}
 
     /// Constructor
     /// @param all_values all values to initialize the composite type with
@@ -192,6 +195,10 @@
         }
     }
 
+    /// @param other the other ScalarArgs to compare against
+    /// @returns true if all values are equal to the values in @p other
+    bool operator==(const ScalarArgs& other) const { return values == other.values; }
+
     /// Valid scalar types for args
     using Storage = std::variant<i32, u32, f32, f16, AInt, AFloat, bool>;
 
@@ -199,10 +206,28 @@
     utils::Vector<Storage, 16> values;
 };
 
+/// @param o the std::ostream to write to
+/// @param args the ScalarArgs
+/// @return the std::ostream so calls can be chained
+inline std::ostream& operator<<(std::ostream& o, const ScalarArgs& args) {
+    o << "[";
+    bool first = true;
+    for (auto& val : args.values) {
+        if (!first) {
+            o << ", ";
+        }
+        first = false;
+        std::visit([&](auto&& v) { o << v; }, val);
+    }
+    o << "]";
+    return o;
+}
+
 using ast_type_func_ptr = const ast::Type* (*)(ProgramBuilder& b);
 using ast_expr_func_ptr = const ast::Expression* (*)(ProgramBuilder& b, ScalarArgs args);
 using ast_expr_from_double_func_ptr = const ast::Expression* (*)(ProgramBuilder& b, double v);
 using sem_type_func_ptr = const sem::Type* (*)(ProgramBuilder& b);
+using type_name_func_ptr = std::string (*)();
 
 template <typename T>
 struct DataType {};
@@ -241,7 +266,7 @@
     /// @param v arg of type double that will be cast to bool.
     /// @return a new AST expression of the bool type
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "bool"; }
@@ -272,7 +297,7 @@
     /// @param v arg of type double that will be cast to i32.
     /// @return a new AST i32 literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "i32"; }
@@ -303,7 +328,7 @@
     /// @param v arg of type double that will be cast to u32.
     /// @return a new AST u32 literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "u32"; }
@@ -334,7 +359,7 @@
     /// @param v arg of type double that will be cast to f32.
     /// @return a new AST f32 literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<f32>(v));
+        return Expr(b, ScalarArgs{static_cast<f32>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "f32"; }
@@ -365,7 +390,7 @@
     /// @param v arg of type double that will be cast to f16.
     /// @return a new AST f16 literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "f16"; }
@@ -395,7 +420,7 @@
     /// @param v arg of type double that will be cast to AFloat.
     /// @return a new AST abstract-float literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "abstract-float"; }
@@ -425,7 +450,7 @@
     /// @param v arg of type double that will be cast to AInt.
     /// @return a new AST abstract-int literal value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() { return "abstract-int"; }
@@ -463,7 +488,7 @@
         const bool one_value = args.values.Length() == 1;
         utils::Vector<const ast::Expression*, N> r;
         for (size_t i = 0; i < N; ++i) {
-            r.Push(DataType<T>::Expr(b, one_value ? args.values[0] : args.values[i]));
+            r.Push(DataType<T>::Expr(b, ScalarArgs{one_value ? args.values[0] : args.values[i]}));
         }
         return r;
     }
@@ -471,7 +496,7 @@
     /// @param v arg of type double that will be cast to ElementType
     /// @return a new AST vector value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() {
@@ -514,7 +539,7 @@
         utils::Vector<const ast::Expression*, N> r;
         for (uint32_t i = 0; i < N; ++i) {
             if (one_value) {
-                r.Push(DataType<vec<M, T>>::Expr(b, args.values[0]));
+                r.Push(DataType<vec<M, T>>::Expr(b, ScalarArgs{args.values[0]}));
             } else {
                 utils::Vector<T, M> v;
                 for (size_t j = 0; j < M; ++j) {
@@ -529,7 +554,7 @@
     /// @param v arg of type double that will be cast to ElementType
     /// @return a new AST matrix value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() {
@@ -585,7 +610,7 @@
     /// @param v arg of type double that will be cast to ElementType
     /// @return a new AST expression of the alias type
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
 
     /// @returns the WGSL name for the type
@@ -626,7 +651,7 @@
     /// @param v arg of type double that will be cast to ElementType
     /// @return a new AST expression of the pointer type
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
 
     /// @returns the WGSL name for the type
@@ -680,7 +705,7 @@
         const bool one_value = args.values.Length() == 1;
         utils::Vector<const ast::Expression*, N> r;
         for (uint32_t i = 0; i < N; i++) {
-            r.Push(DataType<T>::Expr(b, one_value ? args.values[0] : args.values[i]));
+            r.Push(DataType<T>::Expr(b, ScalarArgs{one_value ? args.values[0] : args.values[i]}));
         }
         return r;
     }
@@ -688,7 +713,7 @@
     /// @param v arg of type double that will be cast to ElementType
     /// @return a new AST array value expression
     static inline const ast::Expression* ExprFromDouble(ProgramBuilder& b, double v) {
-        return Expr(b, static_cast<ElementType>(v));
+        return Expr(b, ScalarArgs{static_cast<ElementType>(v)});
     }
     /// @returns the WGSL name for the type
     static inline std::string Name() {
@@ -706,13 +731,23 @@
     ast_expr_from_double_func_ptr expr_from_double;
     /// sem type create function
     sem_type_func_ptr sem;
+    /// type name function
+    type_name_func_ptr name;
 };
 
+/// @param o the std::ostream to write to
+/// @param ptrs the CreatePtrs
+/// @return the std::ostream so calls can be chained
+inline std::ostream& operator<<(std::ostream& o, const CreatePtrs& ptrs) {
+    return o << (ptrs.name ? ptrs.name() : "<unknown>");
+}
+
 /// Returns a CreatePtrs struct instance with all creation pointer types for
 /// type `T`
 template <typename T>
 constexpr CreatePtrs CreatePtrsFor() {
-    return {DataType<T>::AST, DataType<T>::Expr, DataType<T>::ExprFromDouble, DataType<T>::Sem};
+    return {DataType<T>::AST, DataType<T>::Expr, DataType<T>::ExprFromDouble, DataType<T>::Sem,
+            DataType<T>::Name};
 }
 
 /// Value<T> is an instance of a value of type DataType<T>. Useful for storing values to create
@@ -729,15 +764,15 @@
     /// Creates a Value<T> with `args`
     /// @param args the args that will be passed to the expression
     /// @returns a Value<T>
-    static Value Create(ScalarArgs args) { return Value{DataType::Expr, std::move(args)}; }
+    static Value Create(ScalarArgs args) { return Value{CreatePtrsFor<T>(), std::move(args)}; }
 
     /// Creates an `ast::Expression` for the type T passing in previously stored args
     /// @param b the ProgramBuilder
     /// @returns an expression node
-    const ast::Expression* Expr(ProgramBuilder& b) const { return (*expr)(b, args); }
+    const ast::Expression* Expr(ProgramBuilder& b) const { return (*create.expr)(b, args); }
 
-    /// ast expression type create function
-    ast_expr_func_ptr expr;
+    /// functions to create values / types of the value
+    CreatePtrs create;
     /// args to create expression with
     ScalarArgs args;
 };
@@ -764,7 +799,7 @@
 /// Creates a `Value<T>` from a scalar `v`
 template <typename T>
 auto Val(T v) {
-    return Value<T>::Create(v);
+    return Value<T>::Create(ScalarArgs{v});
 }
 
 /// Creates a `Value<vec<N, T>>` from N scalar `args`
diff --git a/src/tint/resolver/type_validation_test.cc b/src/tint/resolver/type_validation_test.cc
index 7cc5cef..1271f06 100644
--- a/src/tint/resolver/type_validation_test.cc
+++ b/src/tint/resolver/type_validation_test.cc
@@ -1165,7 +1165,7 @@
     // var a : texture_storage_1d<ru32int>;
 
     auto* st = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d,
-                                  ast::TexelFormat::kR32Uint, ast::Access::kUndefined);
+                                  ast::TexelFormat::kR32Uint, ast::Access::kInvalid);
 
     GlobalVar("a", st, Group(0_a), Binding(0_a));
 
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index 687d17d..35ba7e9 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -263,7 +263,7 @@
     switch (t->access) {
         case ast::Access::kWrite:
             break;
-        case ast::Access::kUndefined:
+        case ast::Access::kInvalid:
             AddError("storage texture missing access control", t->source);
             return false;
         default:
@@ -344,8 +344,8 @@
                 break;  // Allowed an initializer
             default:
                 // https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
-                // Optionally has an initializer expression, if the variable is in the
-                // private or function address spacees.
+                // Optionally has an initializer expression, if the variable is in the private or
+                // function address spacees.
                 AddError("var of address space '" + utils::ToString(address_space) +
                              "' cannot have an initializer. var initializers are only "
                              "supported for the address spacees "
@@ -440,9 +440,8 @@
                 return false;
             }
 
-            // For uniform buffers, validate that the number of bytes between the
-            // previous member of type struct and the current is a multiple of 16
-            // bytes.
+            // For uniform buffers, validate that the number of bytes between the previous member of
+            // type struct and the current is a multiple of 16 bytes.
             auto* const prev_member = (i == 0) ? nullptr : str->Members()[i - 1];
             if (prev_member && is_uniform_struct(prev_member->Type())) {
                 const uint32_t prev_to_curr_offset = m->Offset() - prev_member->Offset();
@@ -469,24 +468,22 @@
         }
     }
 
-    // For uniform buffer array members, validate that array elements are
-    // aligned to 16 bytes
+    // For uniform buffer array members, validate that array elements are aligned to 16 bytes
     if (auto* arr = store_ty->As<sem::Array>()) {
         // Recurse into the element type.
-        // TODO(crbug.com/tint/1388): Ideally we'd pass the source for nested
-        // element type here, but we can't easily get that from the semantic node.
-        // We should consider recursing through the AST type nodes instead.
+        // TODO(crbug.com/tint/1388): Ideally we'd pass the source for nested element type here, but
+        // we can't easily get that from the semantic node. We should consider recursing through the
+        // AST type nodes instead.
         if (!AddressSpaceLayout(arr->ElemType(), address_space, source, layouts)) {
             return false;
         }
 
         if (address_space == ast::AddressSpace::kUniform) {
-            // We already validated that this array member is itself aligned to 16
-            // bytes above, so we only need to validate that stride is a multiple
-            // of 16 bytes.
+            // We already validated that this array member is itself aligned to 16 bytes above, so
+            // we only need to validate that stride is a multiple of 16 bytes.
             if (arr->Stride() % 16 != 0) {
-                // Since WGSL has no stride attribute, try to provide a useful hint
-                // for how the shader author can resolve the issue.
+                // Since WGSL has no stride attribute, try to provide a useful hint for how the
+                // shader author can resolve the issue.
                 std::string hint;
                 if (arr->ElemType()->is_scalar()) {
                     hint =
@@ -622,9 +619,9 @@
             }
 
             // https://gpuweb.github.io/gpuweb/wgsl/#variable-declaration
-            // The access mode always has a default, and except for variables in the
-            // storage address space, must not be written.
-            if (var->declared_access != ast::Access::kUndefined) {
+            // The access mode always has a default, and except for variables in the storage address
+            // space, must not be written.
+            if (var->declared_access != ast::Access::kInvalid) {
                 if (global->AddressSpace() == ast::AddressSpace::kStorage) {
                     // The access mode for the storage address space can only be 'read' or
                     // 'read_write'.
@@ -684,8 +681,7 @@
         case ast::AddressSpace::kStorage:
         case ast::AddressSpace::kHandle: {
             // https://gpuweb.github.io/gpuweb/wgsl/#resource-interface
-            // Each resource variable must be declared with both group and binding
-            // attributes.
+            // Each resource variable must be declared with both group and binding attributes.
             if (!decl->HasBindingPoint()) {
                 AddError("resource variables require @group and @binding attributes", decl->source);
                 return false;
@@ -709,8 +705,8 @@
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#atomic-types
-// Atomic types may only be instantiated by variables in the workgroup storage
-// class or by storage buffer variables with a read_write access mode.
+// Atomic types may only be instantiated by variables in the workgroup storage class or by storage
+// buffer variables with a read_write access mode.
 bool Validator::AtomicVariable(
     const sem::Variable* var,
     std::unordered_map<const sem::Type*, const Source&> atomic_composite_info) const {
@@ -763,9 +759,8 @@
 
     if (storage_ty->is_handle() && var->declared_address_space != ast::AddressSpace::kNone) {
         // https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
-        // If the store type is a texture type or a sampler type, then the
-        // variable declaration must not have a address space attribute. The
-        // address space will always be handle.
+        // If the store type is a texture type or a sampler type, then the variable declaration must
+        // not have a address space attribute. The address space will always be handle.
         AddError(
             "variables of type '" + sem_.TypeNameOf(storage_ty) + "' must not have a address space",
             var->source);
@@ -1026,7 +1021,7 @@
     }
 
     if (attr->type == ast::InterpolationType::kFlat &&
-        attr->sampling != ast::InterpolationSampling::kNone) {
+        attr->sampling != ast::InterpolationSampling::kInvalid) {
         AddError("flat interpolation attribute must not have a sampling parameter", attr->source);
         return false;
     }
@@ -1127,10 +1122,10 @@
     auto* decl = func->Declaration();
 
     // Use a lambda to validate the entry point attributes for a type.
-    // Persistent state is used to track which builtins and locations have
-    // already been seen, in order to catch conflicts.
-    // TODO(jrprice): This state could be stored in sem::Function instead, and
-    // then passed to sem::Function since it would be useful there too.
+    // Persistent state is used to track which builtins and locations have already been seen, in
+    // order to catch conflicts.
+    // TODO(jrprice): This state could be stored in sem::Function instead, and then passed to
+    // sem::Function since it would be useful there too.
     std::unordered_set<ast::BuiltinValue> builtins;
     std::unordered_set<uint32_t> locations;
     enum class ParamOrRetType {
@@ -1145,8 +1140,7 @@
                                                      bool is_struct_member,
                                                      std::optional<uint32_t> location) {
         // Temporally forbid using f16 types in entry point IO.
-        // TODO(tint:1473, tint:1502): Remove this error after f16 is supported in entry point
-        // IO.
+        // TODO(tint:1473, tint:1502): Remove this error after f16 is supported in entry point IO.
         if (Is<sem::F16>(sem::Type::DeepestElementOf(ty))) {
             AddError("entry point IO of f16 types is not implemented yet", source);
             return false;
@@ -1324,9 +1318,8 @@
         }
     }
 
-    // Clear IO sets after parameter validation. Builtin and location attributes
-    // in return types should be validated independently from those used in
-    // parameters.
+    // Clear IO sets after parameter validation. Builtin and location attributes in return types
+    // should be validated independently from those used in parameters.
     builtins.clear();
     locations.clear();
 
@@ -1352,20 +1345,16 @@
             }
         }
         if (!found) {
-            AddError(
-                "a vertex shader must include the 'position' builtin in its return "
-                "type",
-                decl->source);
+            AddError("a vertex shader must include the 'position' builtin in its return type",
+                     decl->source);
             return false;
         }
     }
 
     if (decl->PipelineStage() == ast::PipelineStage::kCompute) {
         if (!ast::HasAttribute<ast::WorkgroupAttribute>(decl->attributes)) {
-            AddError(
-                "a compute shader must include 'workgroup_size' in its "
-                "attributes",
-                decl->source);
+            AddError("a compute shader must include 'workgroup_size' in its attributes",
+                     decl->source);
             return false;
         }
     }
@@ -1385,17 +1374,15 @@
             IsValidationEnabled(res.first->second->attributes,
                                 ast::DisabledValidation::kBindingPointCollision)) {
             // https://gpuweb.github.io/gpuweb/wgsl/#resource-interface
-            // Bindings must not alias within a shader stage: two different
-            // variables in the resource interface of a given shader must not have
-            // the same group and binding values, when considered as a pair of
-            // values.
+            // Bindings must not alias within a shader stage: two different variables in the
+            // resource interface of a given shader must not have the same group and binding values,
+            // when considered as a pair of values.
             auto func_name = symbols_.NameFor(decl->symbol);
-            AddError("entry point '" + func_name +
-                         "' references multiple variables that use the "
-                         "same resource binding @group(" +
-                         std::to_string(bp.group) + "), @binding(" + std::to_string(bp.binding) +
-                         ")",
-                     var_decl->source);
+            AddError(
+                "entry point '" + func_name +
+                    "' references multiple variables that use the same resource binding @group(" +
+                    std::to_string(bp.group) + "), @binding(" + std::to_string(bp.binding) + ")",
+                var_decl->source);
             AddNote("first resource binding usage declared here", res.first->second->source);
             return false;
         }
@@ -1453,9 +1440,9 @@
     if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ true, current_statement)) {
         auto fail = [&](const char* note_msg, const Source& note_src) {
             constexpr const char* kErrorMsg =
-                "break statement in a continuing block must be the single statement "
-                "of an if statement's true or false block, and that if statement "
-                "must be the last statement of the continuing block";
+                "break statement in a continuing block must be the single statement of an if "
+                "statement's true or false block, and that if statement must be the last statement "
+                "of the continuing block";
             AddError(kErrorMsg, stmt->Declaration()->source);
             AddNote(note_msg, note_src);
             return false;
@@ -1491,15 +1478,14 @@
 
             if (if_stmt->Parent()->Declaration() != continuing) {
                 return fail(
-                    "if statement containing break statement is not directly in "
-                    "continuing block",
+                    "if statement containing break statement is not directly in continuing block",
                     if_stmt->Declaration()->source);
             }
             if (auto* cont_block = continuing->As<ast::BlockStatement>()) {
                 if (if_stmt->Declaration() != cont_block->Last()) {
                     return fail(
-                        "if statement containing break statement is not the last "
-                        "statement of the continuing block",
+                        "if statement containing break statement is not the last statement of the "
+                        "continuing block",
                         if_stmt->Declaration()->source);
                 }
             }
@@ -1570,10 +1556,8 @@
                     if (c->Declaration() != s->Declaration()->body.Back()) {
                         return true;
                     }
-                    AddError(
-                        "a fallthrough statement must not be used in the last switch "
-                        "case",
-                        stmt->Declaration()->source);
+                    AddError("a fallthrough statement must not be used in the last switch case",
+                             stmt->Declaration()->source);
                     return false;
                 }
             }
@@ -1826,8 +1810,8 @@
                 IsValidationEnabled(param->Declaration()->attributes,
                                     ast::DisabledValidation::kIgnoreInvalidPointerArgument)) {
                 AddError(
-                    "expected an address-of expression of a variable identifier "
-                    "expression or a function parameter",
+                    "expected an address-of expression of a variable identifier expression or a "
+                    "function parameter",
                     arg_expr->source);
                 return false;
             }
@@ -1886,8 +1870,7 @@
             auto* value_ty = sem_.TypeOf(value);
             if (member->Type() != value_ty->UnwrapRef()) {
                 AddError(
-                    "type in struct constructor does not match struct member type: "
-                    "expected '" +
+                    "type in struct constructor does not match struct member type: expected '" +
                         sem_.TypeNameOf(member->Type()) + "', found '" + sem_.TypeNameOf(value_ty) +
                         "'",
                     value->source);
@@ -2140,9 +2123,8 @@
         // at least the size of the element type, and be a multiple of the
         // element type's alignment value.
         AddError(
-            "arrays decorated with the stride attribute must have a stride "
-            "that is at least the size of the element type, and be a multiple "
-            "of the element type's alignment value",
+            "arrays decorated with the stride attribute must have a stride that is at least the "
+            "size of the element type, and be a multiple of the element type's alignment value",
             attr->source);
         return false;
     }
@@ -2189,8 +2171,7 @@
             }
         } else if (!IsFixedFootprint(member->Type())) {
             AddError(
-                "a struct that contains a runtime array cannot be nested inside "
-                "another struct",
+                "a struct that contains a runtime array cannot be nested inside another struct",
                 member->Declaration()->source);
             return false;
         }
@@ -2283,8 +2264,8 @@
         AddError("cannot apply 'location' attribute to declaration of type '" + invalid_type + "'",
                  source);
         AddNote(
-            "'location' attribute must only be applied to declarations of "
-            "numeric scalar or numeric vector type",
+            "'location' attribute must only be applied to declarations of numeric scalar or "
+            "numeric vector type",
             loc_attr->source);
         return false;
     }
@@ -2304,11 +2285,9 @@
                        const sem::Type* ret_type,
                        sem::Statement* current_statement) const {
     if (func_type->UnwrapRef() != ret_type) {
-        AddError(
-            "return statement type must match its function "
-            "return type, returned '" +
-                sem_.TypeNameOf(ret_type) + "', expected '" + sem_.TypeNameOf(func_type) + "'",
-            ret->source);
+        AddError("return statement type must match its function return type, returned '" +
+                     sem_.TypeNameOf(ret_type) + "', expected '" + sem_.TypeNameOf(func_type) + "'",
+                 ret->source);
         return false;
     }
 
@@ -2327,10 +2306,8 @@
 bool Validator::SwitchStatement(const ast::SwitchStatement* s) {
     auto* cond_ty = sem_.TypeOf(s->condition)->UnwrapRef();
     if (!cond_ty->is_integer_scalar()) {
-        AddError(
-            "switch statement selector expression must be of a "
-            "scalar integer type",
-            s->condition->source);
+        AddError("switch statement selector expression must be of a scalar integer type",
+                 s->condition->source);
         return false;
     }
 
@@ -2351,8 +2328,7 @@
         for (auto* selector : case_stmt->selectors) {
             if (cond_ty != sem_.TypeOf(selector)) {
                 AddError(
-                    "the case selector values must have the same "
-                    "type as the selector expression.",
+                    "the case selector values must have the same type as the selector expression.",
                     case_stmt->source);
                 return false;
             }
@@ -2397,8 +2373,8 @@
         if (!ty->IsConstructible() &&
             !ty->IsAnyOf<sem::Pointer, sem::Texture, sem::Sampler, sem::AbstractNumeric>()) {
             AddError("cannot assign '" + sem_.TypeNameOf(rhs_ty) +
-                         "' to '_'. '_' can only be assigned a constructible, pointer, "
-                         "texture or sampler type",
+                         "' to '_'. '_' can only be assigned a constructible, pointer, texture or "
+                         "sampler type",
                      rhs->source);
             return false;
         }
diff --git a/src/tint/sem/pointer.cc b/src/tint/sem/pointer.cc
index 3918233..cb73724 100644
--- a/src/tint/sem/pointer.cc
+++ b/src/tint/sem/pointer.cc
@@ -25,7 +25,7 @@
 Pointer::Pointer(const Type* subtype, ast::AddressSpace address_space, ast::Access access)
     : subtype_(subtype), address_space_(address_space), access_(access) {
     TINT_ASSERT(Semantic, !subtype->Is<Reference>());
-    TINT_ASSERT(Semantic, access != ast::Access::kUndefined);
+    TINT_ASSERT(Semantic, access != ast::Access::kInvalid);
 }
 
 size_t Pointer::Hash() const {
diff --git a/src/tint/sem/reference.cc b/src/tint/sem/reference.cc
index a3a9f24..297b779 100644
--- a/src/tint/sem/reference.cc
+++ b/src/tint/sem/reference.cc
@@ -24,7 +24,7 @@
 Reference::Reference(const Type* subtype, ast::AddressSpace address_space, ast::Access access)
     : subtype_(subtype), address_space_(address_space), access_(access) {
     TINT_ASSERT(Semantic, !subtype->Is<Reference>());
-    TINT_ASSERT(Semantic, access != ast::Access::kUndefined);
+    TINT_ASSERT(Semantic, access != ast::Access::kInvalid);
 }
 
 size_t Reference::Hash() const {
diff --git a/src/tint/templates/enums.tmpl.inc b/src/tint/templates/enums.tmpl.inc
index d05d763..4726d80 100644
--- a/src/tint/templates/enums.tmpl.inc
+++ b/src/tint/templates/enums.tmpl.inc
@@ -28,6 +28,14 @@
 /// @returns the parsed enum, or {{$enum}}::kInvalid if the string could not be parsed.
 {{$enum}} Parse{{$enum}}(std::string_view str);
 
+constexpr const char* k{{$enum}}Strings[] = {
+{{-   range $entry := $.Entries }}
+{{-     if not $entry.IsInternal}}
+    "{{$entry.Name}}",
+{{-     end }}
+{{-   end }}
+};
+
 {{- end -}}
 
 
diff --git a/src/tint/transform/binding_remapper.cc b/src/tint/transform/binding_remapper.cc
index a9a3dfb..66d8e99 100644
--- a/src/tint/transform/binding_remapper.cc
+++ b/src/tint/transform/binding_remapper.cc
@@ -121,7 +121,7 @@
             auto ac_it = remappings->access_controls.find(from);
             if (ac_it != remappings->access_controls.end()) {
                 ast::Access ac = ac_it->second;
-                if (ac > ast::Access::kLastValid) {
+                if (ac == ast::Access::kInvalid) {
                     ctx.dst->Diagnostics().add_error(
                         diag::System::Transform,
                         "invalid access mode (" + std::to_string(static_cast<uint32_t>(ac)) + ")");
diff --git a/src/tint/transform/canonicalize_entry_point_io.cc b/src/tint/transform/canonicalize_entry_point_io.cc
index 0ff1084..38a1b28 100644
--- a/src/tint/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/transform/canonicalize_entry_point_io.cc
@@ -45,6 +45,42 @@
     std::optional<uint32_t> location;
 };
 
+/// FXC is sensitive to field order in structures, this is used by StructMemberComparator to ensure
+/// that FXC is happy with the order of emitted fields.
+uint32_t BuiltinOrder(ast::BuiltinValue builtin) {
+    switch (builtin) {
+        case ast::BuiltinValue::kPosition:
+            return 1;
+        case ast::BuiltinValue::kVertexIndex:
+            return 2;
+        case ast::BuiltinValue::kInstanceIndex:
+            return 3;
+        case ast::BuiltinValue::kFrontFacing:
+            return 4;
+        case ast::BuiltinValue::kFragDepth:
+            return 5;
+        case ast::BuiltinValue::kLocalInvocationId:
+            return 6;
+        case ast::BuiltinValue::kLocalInvocationIndex:
+            return 7;
+        case ast::BuiltinValue::kGlobalInvocationId:
+            return 8;
+        case ast::BuiltinValue::kWorkgroupId:
+            return 9;
+        case ast::BuiltinValue::kNumWorkgroups:
+            return 10;
+        case ast::BuiltinValue::kSampleIndex:
+            return 11;
+        case ast::BuiltinValue::kSampleMask:
+            return 12;
+        case ast::BuiltinValue::kPointSize:
+            return 13;
+        default:
+            break;
+    }
+    return 0;
+}
+
 /// Comparison function used to reorder struct members such that all members with
 /// location attributes appear first (ordered by location slot), followed by
 /// those with builtin attributes.
@@ -68,8 +104,8 @@
             // `b` has location attribute and `a` does not: `b` goes first.
             return false;
         }
-        // Both are builtins: order doesn't matter, just use enum value.
-        return a_blt->builtin < b_blt->builtin;
+        // Both are builtins: order matters for FXC.
+        return BuiltinOrder(a_blt->builtin) < BuiltinOrder(b_blt->builtin);
     }
 }
 
@@ -187,7 +223,7 @@
                 (ast::HasAttribute<ast::LocationAttribute>(attributes) ||
                  cfg.shader_style == ShaderStyle::kSpirv)) {
                 attributes.Push(ctx.dst->Interpolate(ast::InterpolationType::kFlat,
-                                                     ast::InterpolationSampling::kNone));
+                                                     ast::InterpolationSampling::kInvalid));
             }
 
             // Disable validation for use of the `input` address space.
@@ -256,7 +292,7 @@
             ast::HasAttribute<ast::LocationAttribute>(attributes) &&
             !ast::HasAttribute<ast::InterpolateAttribute>(attributes)) {
             attributes.Push(ctx.dst->Interpolate(ast::InterpolationType::kFlat,
-                                                 ast::InterpolationSampling::kNone));
+                                                 ast::InterpolationSampling::kInvalid));
         }
 
         // In GLSL, if it's a builtin, override the name with the
diff --git a/src/tint/transform/clamp_frag_depth.cc b/src/tint/transform/clamp_frag_depth.cc
new file mode 100644
index 0000000..1be231a
--- /dev/null
+++ b/src/tint/transform/clamp_frag_depth.cc
@@ -0,0 +1,202 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/clamp_frag_depth.h"
+
+ #include <utility>
+
+#include "src/tint/ast/attribute.h"
+#include "src/tint/ast/builtin_attribute.h"
+#include "src/tint/ast/builtin_value.h"
+#include "src/tint/ast/function.h"
+#include "src/tint/ast/module.h"
+#include "src/tint/ast/struct.h"
+#include "src/tint/ast/type.h"
+#include "src/tint/program_builder.h"
+#include "src/tint/sem/function.h"
+#include "src/tint/sem/statement.h"
+#include "src/tint/sem/struct.h"
+#include "src/tint/utils/scoped_assignment.h"
+#include "src/tint/utils/vector.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::ClampFragDepth);
+
+namespace tint::transform {
+
+namespace {
+
+bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attributes) {
+    for (auto* attribute : attributes) {
+        if (auto* builtin_attribute = attribute->As<ast::BuiltinAttribute>()) {
+            if (builtin_attribute->builtin == ast::BuiltinValue::kFragDepth) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool ReturnsFragDepthAsValue(const ast::Function* fn) {
+    return ContainsFragDepth(fn->return_type_attributes);
+}
+
+bool ReturnsFragDepthInStruct(const sem::Info& sem, const ast::Function* fn) {
+    if (auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()) {
+        for (auto* member : struct_ty->Members()) {
+            if (ContainsFragDepth(member->Declaration()->attributes)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+}  // anonymous namespace
+
+ClampFragDepth::ClampFragDepth() = default;
+ClampFragDepth::~ClampFragDepth() = default;
+
+bool ClampFragDepth::ShouldRun(const Program* program, const DataMap&) const {
+    auto& sem = program->Sem();
+
+    for (auto* fn : program->AST().Functions()) {
+        if (fn->PipelineStage() == ast::PipelineStage::kFragment &&
+            (ReturnsFragDepthAsValue(fn) || ReturnsFragDepthInStruct(sem, fn))) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void ClampFragDepth::Run(CloneContext& ctx, const DataMap&, DataMap&) const {
+    // Abort on any use of push constants in the module.
+    for (auto* global : ctx.src->AST().GlobalVariables()) {
+        if (auto* var = global->As<ast::Var>()) {
+            if (var->declared_address_space == ast::AddressSpace::kPushConstant) {
+                TINT_ICE(Transform, ctx.dst->Diagnostics())
+                    << "ClampFragDepth doesn't know how to handle module that already use push "
+                       "constants.";
+                return;
+            }
+        }
+    }
+
+    auto& b = *ctx.dst;
+    auto& sem = ctx.src->Sem();
+    auto& sym = ctx.src->Symbols();
+
+    // At least one entry-point needs clamping. Add the following to the module:
+    //
+    //   enable chromium_experimental_push_constant;
+    //
+    //   struct FragDepthClampArgs {
+    //       min : f32,
+    //       max : f32,
+    //   }
+    //   var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+    //
+    //   fn clamp_frag_depth(v : f32) -> f32 {
+    //       return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+    //   }
+    b.Enable(ast::Extension::kChromiumExperimentalPushConstant);
+
+    b.Structure(b.Symbols().New("FragDepthClampArgs"),
+                utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
+
+    auto args_sym = b.Symbols().New("frag_depth_clamp_args");
+    b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), ast::AddressSpace::kPushConstant);
+
+    auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
+    b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),
+           utils::Vector{b.Return(b.Call("clamp", "v", b.MemberAccessor(args_sym, "min"),
+                                         b.MemberAccessor(args_sym, "max")))});
+
+    // If true, the currently cloned function returns frag depth directly as a scalar
+    bool returns_frag_depth_as_value = false;
+
+    // If valid, the currently cloned function returns frag depth in a struct
+    // The symbol is the name of the helper function to apply the depth clamping.
+    Symbol returns_frag_depth_as_struct_helper;
+
+    // Map of io struct to helper function to return the structure with the depth clamping applied.
+    utils::Hashmap<const ast::Struct*, Symbol, 4u> io_structs_clamp_helpers;
+
+    // Register a callback that will be called for each visted AST function.
+    // This call wraps the cloning of the function's statements, and will assign to
+    // `returns_frag_depth_as_value` or `returns_frag_depth_as_struct_helper` if the function's
+    // return value requires depth clamping.
+    ctx.ReplaceAll([&](const ast::Function* fn) {
+        if (fn->PipelineStage() != ast::PipelineStage::kFragment) {
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        if (ReturnsFragDepthAsValue(fn)) {
+            TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_value, true);
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        if (ReturnsFragDepthInStruct(sem, fn)) {
+            // At most once per I/O struct, add the conversion function:
+            //
+            //   fn clamp_frag_depth_S(s : S) -> S {
+            //       return S(s.first, s.second, clamp_frag_depth(s.frag_depth), s.last);
+            //   }
+            auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()->Declaration();
+            auto helper = io_structs_clamp_helpers.GetOrCreate(struct_ty, [&] {
+                auto* return_ty = fn->return_type;
+                auto fn_sym = b.Symbols().New("clamp_frag_depth_" +
+                                              sym.NameFor(return_ty->As<ast::TypeName>()->name));
+
+                utils::Vector<const ast::Expression*, 8u> constructor_args;
+                for (auto* member : struct_ty->members) {
+                    const ast::Expression* arg = b.MemberAccessor("s", ctx.Clone(member->symbol));
+                    if (ContainsFragDepth(member->attributes)) {
+                        arg = b.Call(base_fn_sym, arg);
+                    }
+                    constructor_args.Push(arg);
+                }
+                utils::Vector params{b.Param("s", ctx.Clone(return_ty))};
+                utils::Vector body{
+                    b.Return(b.Construct(ctx.Clone(return_ty), std::move(constructor_args))),
+                };
+                b.Func(fn_sym, params, ctx.Clone(return_ty), body);
+                return fn_sym;
+            });
+
+            TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_struct_helper, helper);
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        return ctx.CloneWithoutTransform(fn);
+    });
+
+    // Replace the return statements `return expr` with `return clamp_frag_depth(expr)`.
+    ctx.ReplaceAll([&](const ast::ReturnStatement* stmt) -> const ast::ReturnStatement* {
+        if (returns_frag_depth_as_value) {
+            return b.Return(stmt->source, b.Call(base_fn_sym, ctx.Clone(stmt->value)));
+        }
+        if (returns_frag_depth_as_struct_helper.IsValid()) {
+            return b.Return(stmt->source,
+                            b.Call(returns_frag_depth_as_struct_helper, ctx.Clone(stmt->value)));
+        }
+        return nullptr;
+    });
+
+    ctx.Clone();
+}
+
+}  // namespace tint::transform
diff --git a/src/tint/transform/clamp_frag_depth.h b/src/tint/transform/clamp_frag_depth.h
new file mode 100644
index 0000000..3b15f11
--- /dev/null
+++ b/src/tint/transform/clamp_frag_depth.h
@@ -0,0 +1,81 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_
+#define SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_
+
+#include "src/tint/transform/transform.h"
+
+// Forward declarations
+namespace tint {
+class CloneContext;
+}  // namespace tint
+
+namespace tint::transform {
+
+/// Add clamping of the `@builtin(frag_depth)` output of fragment shaders using two push constants
+/// provided by the outside environment. For example the following code:
+///
+/// ```
+///   @fragment fn main() -> @builtin(frag_depth) f32 {
+///       return 0.0;
+///   }
+/// ```
+///
+/// Is transformed to:
+///
+/// ```
+///   enable chromium_experimental_push_constant;
+///
+///   struct FragDepthClampArgs {
+///     min : f32,
+///     max : f32,
+///   }
+///
+///   var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+///
+///   fn clamp_frag_depth(v : f32) -> f32 {
+///     return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+///   }
+///
+///   @fragment
+///   fn main() -> @builtin(frag_depth) f32 {
+///     return clamp_frag_depth(0.0);
+///   }
+/// ```
+class ClampFragDepth final : public Castable<ClampFragDepth, Transform> {
+  public:
+    /// Constructor
+    ClampFragDepth();
+    /// Destructor
+    ~ClampFragDepth() override;
+
+    /// @param program the program to inspect
+    /// @param data optional extra transform-specific input data
+    /// @returns true if this transform should be run for the given program
+    bool ShouldRun(const Program* program, const DataMap& data = {}) const override;
+
+  protected:
+    /// Runs the transform using the CloneContext built for transforming a
+    /// program. Run() is responsible for calling Clone() on the CloneContext.
+    /// @param ctx the CloneContext primed with the input program and
+    /// ProgramBuilder
+    /// @param inputs optional extra transform-specific input data
+    /// @param outputs optional extra transform-specific output data
+    void Run(CloneContext& ctx, const DataMap& inputs, DataMap& outputs) const override;
+};
+
+}  // namespace tint::transform
+
+#endif  // SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_
diff --git a/src/tint/transform/clamp_frag_depth_test.cc b/src/tint/transform/clamp_frag_depth_test.cc
new file mode 100644
index 0000000..b94d5af
--- /dev/null
+++ b/src/tint/transform/clamp_frag_depth_test.cc
@@ -0,0 +1,381 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/clamp_frag_depth.h"
+
+#include "src/tint/transform/test_helper.h"
+
+namespace tint::transform {
+namespace {
+
+using ClampFragDepthTest = TransformTest;
+
+TEST_F(ClampFragDepthTest, ShouldRunEmptyModule) {
+    auto* src = R"()";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunNoFragmentShader) {
+    auto* src = R"(
+        fn f() -> f32 {
+            return 0.0;
+        }
+
+        @compute @workgroup_size(1) fn cs() {
+        }
+
+        @vertex fn vs() -> @builtin(position) vec4<f32> {
+            return vec4<f32>();
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragmentShaderNoReturnType) {
+    auto* src = R"(
+        @fragment fn main() {
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragmentShaderNoFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @location(0) f32 {
+            return 0.0;
+        }
+
+        struct S {
+            @location(0) a : f32,
+            @builtin(sample_mask) b : u32,
+        }
+        @fragment fn main2() -> S {
+            return S();
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragDepthAsDirectReturn) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+    )";
+
+    EXPECT_TRUE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragDepthInStruct) {
+    auto* src = R"(
+        struct S {
+            @location(0) a : f32,
+            @builtin(frag_depth) b : f32,
+            @location(1) c : f32,
+        }
+        @fragment fn main() -> S {
+            return S();
+        }
+    )";
+
+    EXPECT_TRUE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, SingleReturnOfFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  return clamp_frag_depth(0.0);
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, MultipleReturnOfFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            if (false) {
+                return 1.0;
+            }
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  if (false) {
+    return clamp_frag_depth(1.0);
+  }
+  return clamp_frag_depth(0.0);
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, OtherFunctionWithoutFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+        @fragment fn friend() -> @location(0) f32 {
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  return clamp_frag_depth(0.0);
+}
+
+@fragment
+fn friend() -> @location(0) f32 {
+  return 0.0;
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, SimpleReturnOfStruct) {
+    auto* src = R"(
+        struct S {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+
+        @fragment fn main() -> S {
+            return S(0.0);
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn main() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, MixOfFunctionReturningStruct) {
+    auto* src = R"(
+        struct S {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+        struct S2 {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+
+        @fragment fn returnS() -> S {
+            return S(0.0);
+        }
+        @fragment fn againReturnS() -> S {
+            return S(0.0);
+        }
+        @fragment fn returnS2() -> S2 {
+            return S2(0.0);
+        }
+    )";
+
+    // clamp_frag_depth_S is emitted only once.
+    // S2 gets its own clamping function.
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+struct S2 {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn returnS() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+
+@fragment
+fn againReturnS() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+
+fn clamp_frag_depth_S2(s : S2) -> S2 {
+  return S2(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn returnS2() -> S2 {
+  return clamp_frag_depth_S2(S2(0.0));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, ComplexIOStruct) {
+    auto* src = R"(
+        struct S {
+            @location(0) blou : vec4<f32>,
+            @location(1) bi : vec4<f32>,
+            @builtin(frag_depth) frag_depth : f32,
+            @location(2) boul : i32,
+            @builtin(sample_mask) ga : u32,
+        }
+
+        @fragment fn main() -> S {
+            return S(vec4<f32>(), vec4<f32>(), 0.0, 1, 0u);
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @location(0)
+  blou : vec4<f32>,
+  @location(1)
+  bi : vec4<f32>,
+  @builtin(frag_depth)
+  frag_depth : f32,
+  @location(2)
+  boul : i32,
+  @builtin(sample_mask)
+  ga : u32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(s.blou, s.bi, clamp_frag_depth(s.frag_depth), s.boul, s.ga);
+}
+
+@fragment
+fn main() -> S {
+  return clamp_frag_depth_S(S(vec4<f32>(), vec4<f32>(), 0.0, 1, 0u));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace tint::transform
diff --git a/src/tint/transform/std140_exhaustive_test.cc b/src/tint/transform/std140_exhaustive_test.cc
new file mode 100644
index 0000000..01d2dae
--- /dev/null
+++ b/src/tint/transform/std140_exhaustive_test.cc
@@ -0,0 +1,4872 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/std140.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "src/tint/transform/test_helper.h"
+#include "src/tint/utils/string.h"
+
+namespace tint::transform {
+namespace {
+
+enum class MatrixType { f32, f16 };
+
+struct MatrixCase {
+    uint32_t columns;
+    uint32_t rows;
+    MatrixType type;
+
+    size_t ElementSize() const { return type == MatrixType::f16 ? 2 : 4; }
+
+    size_t ColumnVectorAlign() const { return (rows == 3 ? 4 : rows) * ElementSize(); }
+
+    bool NotStd140Compatible() const { return ColumnVectorAlign() != 16; }
+
+    // Return if this matrix type can be used as element type of an uniform buffer, i.e. the
+    // array stride is multiple of 16.
+    bool CanBeUsedAsUniformArrayElememts() const {
+        const size_t array_stride = columns * ColumnVectorAlign();
+        return (array_stride % 16 == 0);
+    }
+
+    std::string Shape() const { return std::to_string(columns) + "x" + std::to_string(rows); }
+
+    std::string ElementType() const { return type == MatrixType::f16 ? "f16" : "f32"; }
+
+    std::string Mat() const { return "mat" + Shape() + "<" + ElementType() + ">"; }
+
+    std::string ColumnVector() const {
+        return "vec" + std::to_string(rows) + "<" + (type == MatrixType::f32 ? "f32" : "f16") + ">";
+    }
+
+    std::string ColumnVectorSwizzle() const {
+        switch (rows) {
+            case 2:
+                return "yx";
+            case 3:
+                return "yzx";
+            case 4:
+                return "wzxy";
+        }
+        return "";
+    }
+
+    // For each column, replaces "${col_id_for_tmpl}" by column index in `tmpl` to get a string, and
+    // join all these strings with `seperator`. If `tmpl_for_last_column` is not empty, use it
+    // instead of `tmpl` for the last column.
+    std::string JoinTemplatedStringForEachMatrixColumn(
+        std::string tmpl,
+        std::string seperator,
+        std::string tmpl_for_last_column = "") const {
+        std::string result;
+        if (tmpl_for_last_column.size() == 0) {
+            tmpl_for_last_column = tmpl;
+        }
+        for (size_t c = 0; c < columns - 1; c++) {
+            if (c > 0) {
+                result += seperator;
+            }
+            std::string string_for_current_column =
+                utils::ReplaceAll(tmpl, "${col_id_for_tmpl}", std::to_string(c));
+            result += string_for_current_column;
+        }
+        result += seperator;
+        std::string string_for_last_column = utils::ReplaceAll(
+            tmpl_for_last_column, "${col_id_for_tmpl}", std::to_string(columns - 1));
+        result += string_for_last_column;
+        return result;
+    }
+
+    std::string ExpendedColumnVectors(uint32_t leading_space, std::string name) const {
+        std::string space(leading_space, ' ');
+        return JoinTemplatedStringForEachMatrixColumn(
+            space + name + "${col_id_for_tmpl} : " + ColumnVector() + ",", "\n");
+    }
+
+    std::string ExpendedColumnVectorsInline(std::string name, std::string seperator) const {
+        return JoinTemplatedStringForEachMatrixColumn(name + "${col_id_for_tmpl}", seperator);
+    }
+
+    std::string ExpendedColumnVectorsWithLastSize(uint32_t leading_space,
+                                                  std::string name,
+                                                  uint32_t last_size) const {
+        std::string space(leading_space, ' ');
+        return JoinTemplatedStringForEachMatrixColumn(
+            space + name + "${col_id_for_tmpl} : " + ColumnVector() + ",", "\n",
+            space + "@size(" + std::to_string(last_size) + ")\n" + space + name +
+                "${col_id_for_tmpl} : " + ColumnVector() + ",");
+    }
+
+    // Replace user-given fields and predefined fields in a given string `str`.
+    // First, for each pair of string in `replacement_pairs`, replace all occurrences of the first
+    // string of pair with second string. Then, replace several predefined fields with the matrix
+    // information. E.g. for a matrix mat4x3<f32>, would replace "${mat}" with "mat4x3<f32>",
+    // replace "${shape}" with "4x3", "${elem_type}" with "f32", "${col_vector_type}" with
+    // "vec3<f32>", and "${swizzle}" with "yzx".
+    std::string ReplaceFieldsInString(
+        std::string str,
+        std::initializer_list<std::pair<std::string, std::string>> replacement_pairs = {}) const {
+        for (auto& replace : replacement_pairs) {
+            str = utils::ReplaceAll(str, replace.first, replace.second);
+        }
+        str = utils::ReplaceAll(str, "${mat}", Mat());
+        str = utils::ReplaceAll(str, "${shape}", Shape());
+        str = utils::ReplaceAll(str, "${elem_type}", ElementType());
+        str = utils::ReplaceAll(str, "${col_vector_type}", ColumnVector());
+        str = utils::ReplaceAll(str, "${swizzle}", ColumnVectorSwizzle());
+        return str;
+    }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const MatrixCase& c) {
+    return os << c.Mat();
+}
+
+using Std140Test_Matrix = TransformTestWithParam<MatrixCase>;
+
+TEST_P(Std140Test_Matrix, SingleStructMatUniform) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")}});
+
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, CustomAlign) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @align(128)
+  m : ${mat},
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @align(128)
+  m : ${mat},
+  after : i32,
+}
+
+struct S_std140 {
+  before : i32,
+  @align(128i)
+${col_vectors}
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, CustomSizeMat) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @size(128)
+  m : ${mat},
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        uint32_t last_size =
+            128 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+
+        expect = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @size(128)
+  m : ${mat},
+  after : i32,
+}
+
+struct S_std140 {
+  before : i32,
+${col_vectors}
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, CustomAlignAndSize) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @align(128) @size(128)
+  m : ${mat},
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        uint32_t last_size =
+            128 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+
+        expect = R"(
+enable f16;
+
+struct S {
+  before : i32,
+  @align(128) @size(128)
+  m : ${mat},
+  after : i32,
+}
+
+struct S_std140 {
+  before : i32,
+  @align(128i)
+${col_vectors}
+  after : i32,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, MatrixUsageInForLoop) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  for(var i = u32(s.m[0][0]); (i < u32(s.m[i][1])); i += u32(s.m[1][i])) {
+  }
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m_p0_1(p0 : u32) -> ${elem_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  for(var i = u32(s.m_0[0u]); (i < u32(load_s_m_p0_1(u32(i)))); i += u32(s.m_1[i])) {
+  }
+}
+)";
+
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.m_0[1u];
+        //   }
+        //   case 1u: {
+        //     return s.m_1[1u];
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.m_${col_id_for_tmpl}[1u];
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadMatrix) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> m : ${mat};
+
+fn f() {
+  let l = m;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> m : mat${shape}_${elem_type};
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = conv_mat${shape}_${elem_type}(m);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadColumn_ConstIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let l = a[${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn f() {
+  let l = a.col${cloumn_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${cloumn_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${cloumn_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadColumn_VariableIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn load_a_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a.col0;
+        //   }
+        //   case 1u: {
+        //     return a.col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a.col${col_id_for_tmpl};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadColumnSwizzle_ConstIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let l = a[${cloumn_index}].${swizzle};
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn f() {
+  let l = a.col${cloumn_index}.${swizzle};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${cloumn_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${cloumn_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadColumnSwizzle_VariableIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let I = 1;
+  let l = a[I].${swizzle};
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn load_a_p0_${swizzle}(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0_${swizzle}(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a.col0.${swizzle};
+        //   }
+        //   case 1u: {
+        //     return a.col1.${swizzle};
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a.col${col_id_for_tmpl}.${swizzle};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadScalar_ConstColumnIndex_ConstRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let l = a[${col_index}][${row_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn f() {
+  let l = a.col${col_index}[${row_index}u];
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        for (uint32_t row = 0; row < matrix.rows; row++) {
+            std::string src = utils::ReplaceAll(tmpl_src, "${col_index}", std::to_string(col));
+            src = utils::ReplaceAll(src, "${row_index}", std::to_string(row));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${col_index}", std::to_string(col));
+            expect = utils::ReplaceAll(expect, "${row_index}", std::to_string(row));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got)) << "accessing col " << col << " row " << row;
+        }
+    }
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadScalar_VariableColumnIndex_ConstRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let I = 0;
+  let l = a[I][${row_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn load_a_p0_${row_index}(p0 : u32) -> ${elem_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_a_p0_${row_index}(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a.col0[${row_index}u];
+        //   }
+        //   case 1u: {
+        //     return a.col1[${row_index}u];
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a.col${col_id_for_tmpl}[${row_index}u];
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t row = 0; row < matrix.rows; row++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${row_index}", std::to_string(row));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${row_index}", std::to_string(row));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing row " << row;
+    }
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadScalar_ConstColumnIndex_VariableRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let I = 0;
+  let l = a[${col_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn f() {
+  let I = 0;
+  let l = a.col${col_index}[I];
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${col_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${col_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, MatUniform_LoadScalar_VariableColumnIndex_VariableRowIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : ${mat};
+
+fn f() {
+  let I = 0;
+  let l = a[I][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : mat${shape}_${elem_type};
+
+fn load_a_p0_p1(p0 : u32, p1 : u32) -> ${elem_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_a_p0_p1(u32(I), u32(I));
+}
+)";
+
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a.col0[p1];
+        //   }
+        //   case 1u: {
+        //     return a.col1[p1];
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a.col${col_id_for_tmpl}[p1];
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_NameCollision) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m_1 : i32,
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m_1 : i32,
+  m : ${mat},
+}
+
+struct S_std140 {
+  m_1 : i32,
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m__")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadStruct) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_S(val : S_std140) -> S {
+  return S(${mat}(${col_vectors_inline}));
+}
+
+fn f() {
+  let l = conv_S(s);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadMatrix) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.m;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m() -> ${mat} {
+  let s = &(s);
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = load_s_m();
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadColumn_ConstIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.m[${col_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+  let l = s.m_${col_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${col_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${col_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadColumn_VariableIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 0;
+  let l = s.m[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_s_m_p0(u32(I));
+}
+)";
+
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.m_0;
+        //   }
+        //   case 1u: {
+        //     return s.m_1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.m_${col_id_for_tmpl};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vector_type}", matrix.ColumnVector()},
+                     {"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadScalar_ConstColumnIndex_ConstRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.m[${col_index}][${row_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+  let l = s.m_${col_index}[${row_index}u];
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        for (uint32_t row = 0; row < matrix.rows; row++) {
+            std::string src = utils::ReplaceAll(tmpl_src, "${col_index}", std::to_string(col));
+            src = utils::ReplaceAll(src, "${row_index}", std::to_string(row));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${col_index}", std::to_string(col));
+            expect = utils::ReplaceAll(expect, "${row_index}", std::to_string(row));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got)) << "accessing col " << col << " row " << row;
+        }
+    }
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadScalar_VariableColumnIndex_ConstRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 0;
+  let l = s.m[I][${row_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m_p0_${row_index}(p0 : u32) -> ${elem_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_s_m_p0_${row_index}(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.m_0[${row_index}u];
+        //   }
+        //   case 1u: {
+        //     return s.m_1[${row_index}u];
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.m_${col_id_for_tmpl}[${row_index}u];
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t row = 0; row < matrix.rows; row++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${row_index}", std::to_string(row));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${row_index}", std::to_string(row));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing row " << row;
+    }
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadScalar_ConstColumnIndex_VariableRowIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 0;
+  let l = s.m[${col_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+  let I = 0;
+  let l = s.m_${col_index}[I];
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${col_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${col_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, StructMatUniform_LoadScalar_VariableColumnIndex_VariableRowIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 0;
+  let l = s.m[I][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m_p0_p1(p0 : u32, p1 : u32) -> ${elem_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_s_m_p0_p1(u32(I), u32(I));
+}
+)";
+
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.m_0[p1];
+        //   }
+        //   case 1u: {
+        //     return s.m_1[p1];
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.m_${col_id_for_tmpl}[p1];
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "m_")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadArray) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let l = a;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(${mat}(${col_vectors_inline}));
+}
+
+fn conv_arr3_S(val : array<S_std140, 3u>) -> array<S, 3u> {
+  var arr : array<S, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_S(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr3_S(a);
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadStruct_ConstIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let l = a[${array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(${mat}(${col_vectors_inline}));
+}
+
+fn f() {
+  let l = conv_S(a[${array_index}u]);
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadStruct_VariableIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(${mat}(${col_vectors_inline}));
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_S(a[I]);
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadMatrix_ConstArrayIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let l = a[${array_index}].m;
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn load_a_${array_index}_m() -> ${mat} {
+  let s = &(a[${array_index}u]);
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = load_a_${array_index}_m();
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadMatrix_VariableArrayIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].m;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn load_a_p0_m(p0 : u32) -> ${mat} {
+  let s = &(a[p0]);
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0_m(u32(I));
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let l = a[${array_index}].m[${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn f() {
+  let l = a[${array_index}u].m_${cloumn_index};
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        for (uint32_t col = 0; col < matrix.columns; col++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+            src = utils::ReplaceAll(src, "${cloumn_index}", std::to_string(col));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+            expect = utils::ReplaceAll(expect, "${cloumn_index}", std::to_string(col));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element " << array_index << " col " << col;
+        }
+    }
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].m[${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].m_${cloumn_index};
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${cloumn_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${cloumn_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[${array_index}].m[I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn load_a_${array_index}_m_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_${array_index}_m_p0(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[${array_index}u].m_0;
+        //   }
+        //   case 1u: {
+        //     return a[${array_index}u].m_1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[${array_index}u].m_${col_id_for_tmpl};
+    })",
+            "\n");
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> a : array<S, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].m[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
+
+fn load_a_p0_m_p1(p0 : u32, p1 : u32) -> ${col_vector_type} {
+  switch(p1) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0_m_p1(u32(I), u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[p0].m_0;
+        //   }
+        //   case 1u: {
+        //     return a[p0].m_1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].m_${col_id_for_tmpl};
+    })",
+            "\n");
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructArrayStructMatUniform_Loads) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct Inner {
+  @size(64)
+  m : ${mat},
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let l_a : array<Outer, 4> = a;
+  let l_a_1 : Outer = a[1];
+  let l_a_I : Outer = a[I];
+  let l_a_2_a : array<Inner, 4> = a[2].a;
+  let l_a_I_a : array<Inner, 4> = a[I].a;
+  let l_a_3_a_1 : Inner = a[3].a[1];
+  let l_a_3_a_I : Inner = a[3].a[I];
+  let l_a_I_a_1 : Inner = a[I].a[1];
+  let l_a_I_a_J : Inner = a[I].a[J];
+  let l_a_0_a_2_m : ${mat} = a[0].a[2].m;
+  let l_a_0_a_I_m : ${mat} = a[0].a[I].m;
+  let l_a_I_a_2_m : ${mat} = a[I].a[2].m;
+  let l_a_I_a_J_m : ${mat} = a[I].a[J].m;
+  let l_a_1_a_3_m_0 : ${col_vector_type} = a[1].a[3].m[0];
+  let l_a_I_a_J_m_K : ${col_vector_type} = a[I].a[J].m[K];
+  let l_a_2_a_0_m_1_0 : ${elem_type} = a[2].a[0].m[1][0];
+  let l_a_I_a_J_m_K_I : ${elem_type} = a[I].a[J].m[K][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct Inner {
+  @size(64)
+  m : ${mat},
+}
+
+struct Inner_std140 {
+${col_vectors}
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+struct Outer_std140 {
+  a : array<Inner_std140, 4u>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
+
+fn conv_Inner(val : Inner_std140) -> Inner {
+  return Inner(${mat}(${col_vectors_inline_conv_Inner}));
+}
+
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+  var arr : array<Inner, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Inner(val[i]);
+  }
+  return arr;
+}
+
+fn conv_Outer(val : Outer_std140) -> Outer {
+  return Outer(conv_arr4_Inner(val.a));
+}
+
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
+  var arr : array<Outer, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Outer(val[i]);
+  }
+  return arr;
+}
+
+fn load_a_0_a_2_m() -> ${mat} {
+  let s = &(a[0u].a[2u]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_0_a_p0_m(p0 : u32) -> ${mat} {
+  let s = &(a[0u].a[p0]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_2_m(p0 : u32) -> ${mat} {
+  let s = &(a[p0].a[2u]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_p1_m(p0 : u32, p1 : u32) -> ${mat} {
+  let s = &(a[p0].a[p1]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_p1_m_p2(p0 : u32, p1 : u32, p2 : u32) -> ${col_vector_type} {
+  switch(p2) {
+${col_table_load_column}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn load_a_p0_a_p1_m_p2_p3(p0 : u32, p1 : u32, p2 : u32, p3 : u32) -> ${elem_type} {
+  switch(p2) {
+${col_table_load_element}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
+  let l_a_1 : Outer = conv_Outer(a[1u]);
+  let l_a_I : Outer = conv_Outer(a[I]);
+  let l_a_2_a : array<Inner, 4> = conv_arr4_Inner(a[2u].a);
+  let l_a_I_a : array<Inner, 4> = conv_arr4_Inner(a[I].a);
+  let l_a_3_a_1 : Inner = conv_Inner(a[3u].a[1u]);
+  let l_a_3_a_I : Inner = conv_Inner(a[3u].a[I]);
+  let l_a_I_a_1 : Inner = conv_Inner(a[I].a[1u]);
+  let l_a_I_a_J : Inner = conv_Inner(a[I].a[J]);
+  let l_a_0_a_2_m : ${mat} = load_a_0_a_2_m();
+  let l_a_0_a_I_m : ${mat} = load_a_0_a_p0_m(u32(I));
+  let l_a_I_a_2_m : ${mat} = load_a_p0_a_2_m(u32(I));
+  let l_a_I_a_J_m : ${mat} = load_a_p0_a_p1_m(u32(I), u32(J));
+  let l_a_1_a_3_m_0 : ${col_vector_type} = a[1u].a[3u].m_0;
+  let l_a_I_a_J_m_K : ${col_vector_type} = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a_2_a_0_m_1_0 : ${elem_type} = a[2u].a[0u].m_1[0u];
+  let l_a_I_a_J_m_K_I : ${elem_type} = load_a_p0_a_p1_m_p2_p3(u32(I), u32(J), u32(K), u32(I));
+}
+)";
+        std::string col_tableLoadColumn = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].a[p1].m_${col_id_for_tmpl};
+    })",
+            "\n");
+        std::string col_tableLoadElement = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].a[p1].m_${col_id_for_tmpl}[p3];
+    })",
+            "\n");
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline_conv_Inner}",
+              matrix.ExpendedColumnVectorsInline("val.m_", ", ")},
+             {"${col_vectors_inline_load_matrix}",
+              matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")},
+             {"${col_table_load_column}", col_tableLoadColumn},
+             {"${col_table_load_element}", col_tableLoadElement}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructArrayStructMatUniform_LoadsViaPtrs) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct Inner {
+  @size(64)
+  m : ${mat},
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let p_a = &(a);
+  let p_a_3 = &((*(p_a))[3]);
+  let p_a_I = &((*(p_a))[I]);
+  let p_a_3_a = &((*(p_a_3)).a);
+  let p_a_I_a = &((*(p_a_I)).a);
+  let p_a_3_a_2 = &((*(p_a_3_a))[2]);
+  let p_a_3_a_I = &((*(p_a_3_a))[I]);
+  let p_a_I_a_2 = &((*(p_a_I_a))[2]);
+  let p_a_I_a_J = &((*(p_a_I_a))[J]);
+  let p_a_3_a_2_m = &((*(p_a_3_a_2)).m);
+  let p_a_3_a_I_m = &((*(p_a_3_a_I)).m);
+  let p_a_I_a_2_m = &((*(p_a_I_a_2)).m);
+  let p_a_I_a_J_m = &((*(p_a_I_a_J)).m);
+  let p_a_3_a_2_m_1 = &((*(p_a_3_a_2_m))[1]);
+  let p_a_I_a_J_m_K = &((*(p_a_I_a_J_m))[K]);
+  let l_a : array<Outer, 4> = *(p_a);
+  let l_a_3 : Outer = *(p_a_3);
+  let l_a_I : Outer = *(p_a_I);
+  let l_a_3_a : array<Inner, 4> = *(p_a_3_a);
+  let l_a_I_a : array<Inner, 4> = *(p_a_I_a);
+  let l_a_3_a_2 : Inner = *(p_a_3_a_2);
+  let l_a_3_a_I : Inner = *(p_a_3_a_I);
+  let l_a_I_a_2 : Inner = *(p_a_I_a_2);
+  let l_a_I_a_J : Inner = *(p_a_I_a_J);
+  let l_a_3_a_2_m : ${mat} = *(p_a_3_a_2_m);
+  let l_a_3_a_I_m : ${mat} = *(p_a_3_a_I_m);
+  let l_a_I_a_2_m : ${mat} = *(p_a_I_a_2_m);
+  let l_a_I_a_J_m : ${mat} = *(p_a_I_a_J_m);
+  let l_a_3_a_2_m_1 : ${col_vector_type} = *(p_a_3_a_2_m_1);
+  let l_a_I_a_J_m_K : ${col_vector_type} = *(p_a_I_a_J_m_K);
+  let l_a_2_a_0_m_1_0 : ${elem_type} = (*(p_a_3_a_2_m_1))[0];
+  let l_a_I_a_J_m_K_I : ${elem_type} = (*(p_a_I_a_J_m_K))[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct Inner {
+  @size(64)
+  m : ${mat},
+}
+
+struct Inner_std140 {
+${col_vectors}
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+struct Outer_std140 {
+  a : array<Inner_std140, 4u>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
+
+fn conv_Inner(val : Inner_std140) -> Inner {
+  return Inner(${mat}(${col_vectors_inline_conv_Inner}));
+}
+
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+  var arr : array<Inner, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Inner(val[i]);
+  }
+  return arr;
+}
+
+fn conv_Outer(val : Outer_std140) -> Outer {
+  return Outer(conv_arr4_Inner(val.a));
+}
+
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
+  var arr : array<Outer, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Outer(val[i]);
+  }
+  return arr;
+}
+
+fn load_a_3_a_2_m() -> ${mat} {
+  let s = &(a[3u].a[2u]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_3_a_p0_m(p0 : u32) -> ${mat} {
+  let s = &(a[3u].a[p0]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_2_m(p0 : u32) -> ${mat} {
+  let s = &(a[p0].a[2u]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_p1_m(p0 : u32, p1 : u32) -> ${mat} {
+  let s = &(a[p0].a[p1]);
+  return ${mat}(${col_vectors_inline_load_matrix});
+}
+
+fn load_a_p0_a_p1_m_p2(p0 : u32, p1 : u32, p2 : u32) -> ${col_vector_type} {
+  switch(p2) {
+${col_table_load_column}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn load_a_p0_a_p1_m_p2_p3(p0 : u32, p1 : u32, p2 : u32, p3 : u32) -> ${elem_type} {
+  switch(p2) {
+${col_table_load_element}
+    default: {
+      return ${elem_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let p_a = conv_arr4_Outer(a);
+  let p_a_3 = conv_Outer(a[3u]);
+  let p_a_I = conv_Outer(a[I]);
+  let p_a_3_a = conv_arr4_Inner(a[3u].a);
+  let p_a_I_a = conv_arr4_Inner(a[I].a);
+  let p_a_3_a_2 = conv_Inner(a[3u].a[2u]);
+  let p_a_3_a_I = conv_Inner(a[3u].a[I]);
+  let p_a_I_a_2 = conv_Inner(a[I].a[2u]);
+  let p_a_I_a_J = conv_Inner(a[I].a[J]);
+  let p_a_3_a_2_m = load_a_3_a_2_m();
+  let p_a_3_a_I_m = load_a_3_a_p0_m(u32(I));
+  let p_a_I_a_2_m = load_a_p0_a_2_m(u32(I));
+  let p_a_I_a_J_m = load_a_p0_a_p1_m(u32(I), u32(J));
+  let p_a_3_a_2_m_1 = a[3u].a[2u].m_1;
+  let p_a_I_a_J_m_K = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
+  let l_a_3 : Outer = conv_Outer(a[3u]);
+  let l_a_I : Outer = conv_Outer(a[I]);
+  let l_a_3_a : array<Inner, 4> = conv_arr4_Inner(a[3u].a);
+  let l_a_I_a : array<Inner, 4> = conv_arr4_Inner(a[I].a);
+  let l_a_3_a_2 : Inner = conv_Inner(a[3u].a[2u]);
+  let l_a_3_a_I : Inner = conv_Inner(a[3u].a[I]);
+  let l_a_I_a_2 : Inner = conv_Inner(a[I].a[2u]);
+  let l_a_I_a_J : Inner = conv_Inner(a[I].a[J]);
+  let l_a_3_a_2_m : ${mat} = load_a_3_a_2_m();
+  let l_a_3_a_I_m : ${mat} = load_a_3_a_p0_m(u32(I));
+  let l_a_I_a_2_m : ${mat} = load_a_p0_a_2_m(u32(I));
+  let l_a_I_a_J_m : ${mat} = load_a_p0_a_p1_m(u32(I), u32(J));
+  let l_a_3_a_2_m_1 : ${col_vector_type} = a[3u].a[2u].m_1;
+  let l_a_I_a_J_m_K : ${col_vector_type} = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a_2_a_0_m_1_0 : ${elem_type} = a[3u].a[2u].m_1[0u];
+  let l_a_I_a_J_m_K_I : ${elem_type} = load_a_p0_a_p1_m_p2_p3(u32(I), u32(J), u32(K), u32(I));
+}
+)";
+        std::string col_tableLoadColumn = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].a[p1].m_${col_id_for_tmpl};
+    })",
+            "\n");
+        std::string col_tableLoadElement = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].a[p1].m_${col_id_for_tmpl}[p3];
+    })",
+            "\n");
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline_conv_Inner}",
+              matrix.ExpendedColumnVectorsInline("val.m_", ", ")},
+             {"${col_vectors_inline_load_matrix}",
+              matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")},
+             {"${col_table_load_column}", col_tableLoadColumn},
+             {"${col_table_load_element}", col_tableLoadElement}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyArray_UniformToStorage) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s = u;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(${mat}(${col_vectors_inline}));
+}
+
+fn conv_arr4_S(val : array<S_std140, 4u>) -> array<S, 4u> {
+  var arr : array<S, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_S(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  s = conv_arr4_S(u);
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyStruct_UniformToWorkgroup) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[0] = u[1];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+var<workgroup> w : array<S, 4>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(val.v, ${mat}(${col_vectors_inline}));
+}
+
+fn f() {
+  w[0] = conv_S(u[1u]);
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyMatrix_UniformToPrivate) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[2].m = u[1].m;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+var<private> p : array<S, 4>;
+
+fn load_u_1_m() -> ${mat} {
+  let s = &(u[1u]);
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  p[2].m = load_u_1_m();
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyColumn_UniformToStorage) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s[3].m[1] = u[2].m[0];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s[3].m[1] = u[2u].m_0;
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyColumnSwizzle_UniformToWorkgroup) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[3].m[1] = u[2].m[0].${swizzle}.${swizzle};
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[3].m[1] = u[2u].m_0.${swizzle}.${swizzle};
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_Matrix, ArrayStructMatUniform_CopyScalar_UniformToPrivate) {
+    auto matrix = GetParam();
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[3].m[1].x = u[2].m[0].y;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : ${mat},
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[3].m[1].x = u[2u].m_0[1u];
+}
+)";
+        uint32_t last_size =
+            64 - static_cast<uint32_t>(matrix.ColumnVectorAlign() * (matrix.columns - 1));
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectorsWithLastSize(2, "m_", last_size)},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("(*(s)).m_", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+INSTANTIATE_TEST_SUITE_P(,
+                         Std140Test_Matrix,
+                         ::testing::ValuesIn(std::vector<MatrixCase>{
+                             {2, 2, MatrixType::f32},
+                             {2, 3, MatrixType::f32},
+                             {2, 4, MatrixType::f32},
+                             {3, 2, MatrixType::f32},
+                             {3, 3, MatrixType::f32},
+                             {3, 4, MatrixType::f32},
+                             {4, 2, MatrixType::f32},
+                             {4, 3, MatrixType::f32},
+                             {4, 4, MatrixType::f32},
+                         }));
+
+using Std140Test_MatrixArray = TransformTestWithParam<MatrixCase>;
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadArray) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let l = a;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr3_mat${shape}_${elem_type}(a);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadMatrix_ConstArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let l = a[${array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = conv_mat${shape}_${elem_type}(a[${array_index}u]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadMatrix_VariableArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat${shape}_${elem_type}(a[I]);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let l = a[${array_index}][${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn f() {
+  let l = a[${array_index}u].col${cloumn_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        for (uint32_t col = 0; col < matrix.columns; col++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+            src = utils::ReplaceAll(src, "${cloumn_index}", std::to_string(col));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+            expect = utils::ReplaceAll(expect, "${cloumn_index}", std::to_string(col));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element " << array_index << " col " << col;
+        }
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].col${cloumn_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${cloumn_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${cloumn_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[${array_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn load_a_${array_index}_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_${array_index}_p0(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[${array_index}u].col0;
+        //   }
+        //   case 1u: {
+        //     return a[${array_index}u].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[${array_index}u].col${col_id_for_tmpl};
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<${mat}, 3>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat${shape}_${elem_type}, 3u>;
+
+fn load_a_p0_p1(p0 : u32, p1 : u32) -> ${col_vector_type} {
+  switch(p1) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0_p1(u32(I), u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[p0].col0;
+        //   }
+        //   case 1u: {
+        //     return a[p0].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0].col${col_id_for_tmpl};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, StructArrayMatUniform_LoadStruct) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn conv_S(val : S_std140) -> S {
+  return S(conv_arr3_mat${shape}_${elem_type}(val.a));
+}
+
+fn f() {
+  let l = conv_S(s);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, StructArrayMatUniform_LoadArray) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.a;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr3_mat${shape}_${elem_type}(s.a);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, StructArrayMatUniform_LoadMatrix_ConstArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.a[${array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = conv_mat${shape}_${elem_type}(s.a[${array_index}u]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, StructArrayMatUniform_LoadMatrix_VariableArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 1;
+  let l = s.a[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat${shape}_${elem_type}(s.a[I]);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, StructArrayMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let l = s.a[${array_index}][${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+  let l = s.a[${array_index}u].col${cloumn_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        for (uint32_t col = 0; col < matrix.columns; col++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+            src = utils::ReplaceAll(src, "${cloumn_index}", std::to_string(col));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+            expect = utils::ReplaceAll(expect, "${cloumn_index}", std::to_string(col));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element " << array_index << " col " << col;
+        }
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       StructArrayMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 1;
+  let l = s.a[I][${cloumn_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+  let I = 1;
+  let l = s.a[I].col${cloumn_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${cloumn_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${cloumn_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing col " << col;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       StructArrayMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 1;
+  let l = s.a[${array_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_a_${array_index}_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_s_a_${array_index}_p0(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.a[${array_index}u].col0;
+        //   }
+        //   case 1u: {
+        //     return s.a[${array_index}u].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.a[${array_index}u].col${col_id_for_tmpl};
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t array_index = 0; array_index < 3; array_index++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${array_index}", std::to_string(array_index));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${array_index}", std::to_string(array_index));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << array_index;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       StructArrayMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  let I = 1;
+  let l = s.a[I][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+struct S {
+  a : array<${mat}, 3>,
+}
+
+struct S_std140 {
+  a : array<mat${shape}_${elem_type}, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_a_p0_p1(p0 : u32, p1 : u32) -> ${col_vector_type} {
+  switch(p1) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_s_a_p0_p1(u32(I), u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return s.a[p0].col0;
+        //   }
+        //   case 1u: {
+        //     return s.a[p0].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return s.a[p0].col${col_id_for_tmpl};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayArrayMatUniform_LoadArrays) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let l = a;
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn conv_arr4_arr3_mat${shape}_${elem_type}(val : array<array<mat${shape}_${elem_type}, 3u>, 4u>) -> array<array<${mat}, 3u>, 4u> {
+  var arr : array<array<${mat}, 3u>, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_arr3_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr4_arr3_mat${shape}_${elem_type}(a);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayArrayMatUniform_LoadArray_ConstOuterArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let l = a[${outer_array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr3_mat${shape}_${elem_type}(a[${outer_array_index}u]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element " << outer;
+    }
+}
+
+TEST_P(Std140Test_MatrixArray, ArrayArrayMatUniform_LoadArray_VariableOuterArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn conv_arr3_mat${shape}_${elem_type}(val : array<mat${shape}_${elem_type}, 3u>) -> array<${mat}, 3u> {
+  var arr : array<${mat}, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat${shape}_${elem_type}(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_arr3_mat${shape}_${elem_type}(a[I]);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray,
+       ArrayArrayMatUniform_LoadMatrix_ConstOuterArrayIndex_ConstInnerArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let l = a[${outer_array_index}][${inner_array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let l = conv_mat${shape}_${elem_type}(a[${outer_array_index}u][${inner_array_index}u]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        for (uint32_t inner = 0; inner < 3; inner++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+            src = utils::ReplaceAll(src, "${inner_array_index}", std::to_string(inner));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+            expect = utils::ReplaceAll(expect, "${inner_array_index}", std::to_string(inner));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element [" << outer << "][" << inner << "]";
+        }
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       ArrayArrayMatUniform_LoadMatrix_ConstOuterArrayIndex_VariableInnerArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[${outer_array_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat${shape}_${elem_type}(a[${outer_array_index}u][I]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element [" << outer << "][I]";
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       ArrayArrayMatUniform_LoadMatrix_VariableOuterArrayIndex_ConstInnerArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][${inner_array_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat${shape}_${elem_type}(a[I][${inner_array_index}u]);
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t inner = 0; inner < 3; inner++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${inner_array_index}", std::to_string(inner));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${inner_array_index}", std::to_string(inner));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element [I][" << inner << "]";
+    }
+}
+
+TEST_P(Std140Test_MatrixArray,
+       ArrayArrayMatUniform_LoadMatrix_VariableOuterArrayIndex_VariableInnerArrayIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][I];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn conv_mat${shape}_${elem_type}(val : mat${shape}_${elem_type}) -> ${mat} {
+  return ${mat}(${col_vectors_inline});
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat${shape}_${elem_type}(a[I][I]);
+}
+)";
+        expect = matrix.ReplaceFieldsInString(
+            expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_P(Std140Test_MatrixArray,
+       ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_ConstInnerArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let l = a[${outer_array_index}][${inner_array_index}][${column_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn f() {
+  let l = a[${outer_array_index}u][${inner_array_index}u].col${column_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect,
+            {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+             {"${col_vectors_inline}", matrix.ExpendedColumnVectorsInline("val.col", ", ")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        for (uint32_t inner = 0; inner < 3; inner++) {
+            for (uint32_t col = 0; col < matrix.columns; col++) {
+                std::string src =
+                    utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+                src = utils::ReplaceAll(src, "${inner_array_index}", std::to_string(inner));
+                src = utils::ReplaceAll(src, "${column_index}", std::to_string(col));
+                std::string expect =
+                    utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+                expect = utils::ReplaceAll(expect, "${inner_array_index}", std::to_string(inner));
+                expect = utils::ReplaceAll(expect, "${column_index}", std::to_string(col));
+
+                auto got = Run<Std140>(src);
+
+                EXPECT_EQ(expect, str(got))
+                    << "accessing array element [" << outer << "][" << inner << "] col " << col;
+            }
+        }
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_ConstInnerArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[${outer_array_index}][${inner_array_index}][I];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn load_a_${outer_array_index}_${inner_array_index}_p0(p0 : u32) -> ${col_vector_type} {
+  switch(p0) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_${outer_array_index}_${inner_array_index}_p0(u32(I));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[${outer_array_index}u][${inner_array_index}u].col0;
+        //   }
+        //   case 1u: {
+        //     return a[${outer_array_index}u][${inner_array_index}u].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[${outer_array_index}u][${inner_array_index}u].col${col_id_for_tmpl};
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        for (uint32_t inner = 0; inner < 3; inner++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+            src = utils::ReplaceAll(src, "${inner_array_index}", std::to_string(inner));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+            expect = utils::ReplaceAll(expect, "${inner_array_index}", std::to_string(inner));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element [" << outer << "][" << inner << "]";
+        }
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_VariableInnerArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[${outer_array_index}][I][${column_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let l = a[${outer_array_index}u][I].col${column_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        for (uint32_t col = 0; col < matrix.columns; col++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+            src = utils::ReplaceAll(src, "${column_index}", std::to_string(col));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+            expect = utils::ReplaceAll(expect, "${column_index}", std::to_string(col));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element [" << outer << "][I] col " << col;
+        }
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_VariableInnerArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[${outer_array_index}][I][J];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn load_a_${outer_array_index}_p0_p1(p0 : u32, p1 : u32) -> ${col_vector_type} {
+  switch(p1) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = load_a_${outer_array_index}_p0_p1(u32(I), u32(J));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[${outer_array_index}u][p0].col0;
+        //   }
+        //   case 1u: {
+        //     return a[${outer_array_index}u][p0].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[${outer_array_index}u][p0].col${col_id_for_tmpl};
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t outer = 0; outer < 4; outer++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${outer_array_index}", std::to_string(outer));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${outer_array_index}", std::to_string(outer));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element [" << outer << "][I]";
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_ConstInnerArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][${inner_array_index}][${column_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][${inner_array_index}u].col${column_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t inner = 0; inner < 3; inner++) {
+        for (uint32_t col = 0; col < matrix.columns; col++) {
+            std::string src =
+                utils::ReplaceAll(tmpl_src, "${inner_array_index}", std::to_string(inner));
+            src = utils::ReplaceAll(src, "${column_index}", std::to_string(col));
+            std::string expect =
+                utils::ReplaceAll(tmpl_expect, "${inner_array_index}", std::to_string(inner));
+            expect = utils::ReplaceAll(expect, "${column_index}", std::to_string(col));
+
+            auto got = Run<Std140>(src);
+
+            EXPECT_EQ(expect, str(got))
+                << "accessing array element [I][" << inner << "] col " << col;
+        }
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_ConstInnerArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][${inner_array_index}][J];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn load_a_p0_${inner_array_index}_p1(p0 : u32, p1 : u32) -> ${col_vector_type} {
+  switch(p1) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = load_a_p0_${inner_array_index}_p1(u32(I), u32(J));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[p0][${inner_array_index}u].col0;
+        //   }
+        //   case 1u: {
+        //     return a[p0][${inner_array_index}u].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0][${inner_array_index}u].col${col_id_for_tmpl};
+    })",
+            "\n");
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                          {"${col_table}", col_table}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t inner = 0; inner < 3; inner++) {
+        std::string src =
+            utils::ReplaceAll(tmpl_src, "${inner_array_index}", std::to_string(inner));
+        std::string expect =
+            utils::ReplaceAll(tmpl_expect, "${inner_array_index}", std::to_string(inner));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element [I][" << inner << "]";
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_VariableInnerArrayIndex_ConstColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string tmpl_src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][J][${column_index}];
+}
+)";
+    tmpl_src = matrix.ReplaceFieldsInString(tmpl_src);
+
+    std::string tmpl_expect;
+    if (matrix.NotStd140Compatible()) {
+        tmpl_expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][J].col${column_index};
+}
+)";
+        tmpl_expect = matrix.ReplaceFieldsInString(
+            tmpl_expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")}});
+    } else {
+        tmpl_expect = tmpl_src;
+    }
+
+    for (uint32_t col = 0; col < matrix.columns; col++) {
+        std::string src = utils::ReplaceAll(tmpl_src, "${column_index}", std::to_string(col));
+        std::string expect = utils::ReplaceAll(tmpl_expect, "${column_index}", std::to_string(col));
+
+        auto got = Run<Std140>(src);
+
+        EXPECT_EQ(expect, str(got)) << "accessing array element [I][J] col " << col;
+    }
+}
+
+TEST_P(
+    Std140Test_MatrixArray,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_VariableInnerArrayIndex_VariableColumnIndex) {
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
+        return;
+    }
+
+    std::string src = R"(
+enable f16;
+
+@group(0) @binding(0) var<uniform> a : array<array<${mat}, 3>, 4>;
+
+fn f() {
+  let I = 0;
+  let J = 1;
+  let K = 2;
+  let l = a[I][J][K];
+}
+)";
+    src = matrix.ReplaceFieldsInString(src);
+
+    std::string expect;
+    if (matrix.NotStd140Compatible()) {
+        expect = R"(
+enable f16;
+
+struct mat${shape}_${elem_type} {
+${col_vectors}
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat${shape}_${elem_type}, 3u>, 4u>;
+
+fn load_a_p0_p1_p2(p0 : u32, p1 : u32, p2 : u32) -> ${col_vector_type} {
+  switch(p2) {
+${col_table}
+    default: {
+      return ${col_vector_type}();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let J = 1;
+  let K = 2;
+  let l = load_a_p0_p1_p2(u32(I), u32(J), u32(K));
+}
+)";
+        // col_table is the switch cases for all column index.
+        // Example for a matrix having 2 columns:
+        //   case 0u: {
+        //     return a[p0][p1].col0;
+        //   }
+        //   case 1u: {
+        //     return a[p0][p1].col1;
+        //   }
+        std::string col_table = matrix.JoinTemplatedStringForEachMatrixColumn(  //
+            R"(    case ${col_id_for_tmpl}u: {
+      return a[p0][p1].col${col_id_for_tmpl};
+    })",
+            "\n");
+        expect = matrix.ReplaceFieldsInString(
+            expect, {{"${col_vectors}", matrix.ExpendedColumnVectors(2, "col")},
+                     {"${col_table}", col_table}});
+    } else {
+        expect = src;
+    }
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+INSTANTIATE_TEST_SUITE_P(,
+                         Std140Test_MatrixArray,
+                         ::testing::ValuesIn(std::vector<MatrixCase>{
+                             {2, 2, MatrixType::f32},
+                             {2, 3, MatrixType::f32},
+                             {2, 4, MatrixType::f32},
+                             {3, 2, MatrixType::f32},
+                             {3, 3, MatrixType::f32},
+                             {3, 4, MatrixType::f32},
+                             {4, 2, MatrixType::f32},
+                             {4, 3, MatrixType::f32},
+                             {4, 4, MatrixType::f32},
+                         }));
+
+}  // namespace
+}  // namespace tint::transform
diff --git a/src/tint/transform/std140_test.cc b/src/tint/transform/std140_test.cc
index 6e0b170..1ec2e09 100644
--- a/src/tint/transform/std140_test.cc
+++ b/src/tint/transform/std140_test.cc
@@ -32,7 +32,7 @@
     EXPECT_FALSE(ShouldRun<Std140>(src));
 }
 
-TEST_F(Std140Test, ShouldRunStructMat2x2Unused) {
+TEST_F(Std140Test, ShouldRunStructMat2x2F32Unused) {
     auto* src = R"(
 struct Unused {
   m : mat2x2<f32>,
@@ -42,30 +42,68 @@
     EXPECT_FALSE(ShouldRun<Std140>(src));
 }
 
-struct ShouldRunCase {
+TEST_F(Std140Test, ShouldRunStructMat2x2F16Unused) {
+    auto* src = R"(
+enable f16;
+
+struct Unused {
+  m : mat2x2<f16>,
+}
+)";
+
+    EXPECT_FALSE(ShouldRun<Std140>(src));
+}
+
+enum class MatrixType { f32, f16 };
+
+struct MatrixCase {
     uint32_t columns;
     uint32_t rows;
-    bool should_run;
+    MatrixType type;
 
-    std::string Mat() const { return "mat" + std::to_string(columns) + "x" + std::to_string(rows); }
+    size_t ElementSize() const { return type == MatrixType::f16 ? 2 : 4; }
+
+    size_t ColumnVectorAlign() const { return (rows == 3 ? 4 : rows) * ElementSize(); }
+
+    bool NotStd140Compatible() const { return ColumnVectorAlign() != 16; }
+
+    // Return if this matrix type can be used as element type of an uniform buffer, i.e. the
+    // array stride is multiple of 16.
+    bool CanBeUsedAsUniformArrayElememts() const {
+        const size_t arrayStride = columns * ColumnVectorAlign();
+        return (arrayStride % 16 == 0);
+    }
+
+    std::string Shape() const { return std::to_string(columns) + "x" + std::to_string(rows); }
+
+    std::string ElementType() const { return type == MatrixType::f16 ? "f16" : "f32"; }
+
+    std::string Mat() const { return "mat" + Shape() + "<" + ElementType() + ">"; }
+
+    // Replace predefined field `${mat}` with the matrix shape. E.g. for a matrix mat4x3<f32>, would
+    // replace "${mat}" with "mat4x3<f32>".
+    std::string ReplaceMatInString(std::string str) const {
+        str = utils::ReplaceAll(str, "${mat}", Mat());
+        return str;
+    }
 };
 
-inline std::ostream& operator<<(std::ostream& os, const ShouldRunCase& c) {
+inline std::ostream& operator<<(std::ostream& os, const MatrixCase& c) {
     return os << c.Mat();
 }
 
-using Std140TestShouldRun = TransformTestWithParam<ShouldRunCase>;
+using Std140TestShouldRun = TransformTestWithParam<MatrixCase>;
 
 TEST_P(Std140TestShouldRun, StructStorage) {
     std::string src = R"(
 struct S {
-  m : ${mat}<f32>,
+  m : ${mat},
 }
 
 @group(0) @binding(0) var<storage> s : S;
 )";
 
-    src = utils::ReplaceAll(src, "${mat}", GetParam().Mat());
+    src = GetParam().ReplaceMatInString(src);
 
     EXPECT_FALSE(ShouldRun<Std140>(src));
 }
@@ -73,57 +111,56 @@
 TEST_P(Std140TestShouldRun, StructUniform) {
     std::string src = R"(
 struct S {
-  m : ${mat}<f32>,
+  m : ${mat},
 }
 
 @group(0) @binding(0) var<uniform> s : S;
 )";
 
-    src = utils::ReplaceAll(src, "${mat}", GetParam().Mat());
+    src = GetParam().ReplaceMatInString(src);
 
-    EXPECT_EQ(ShouldRun<Std140>(src), GetParam().should_run);
+    EXPECT_EQ(ShouldRun<Std140>(src), GetParam().NotStd140Compatible());
 }
 
 TEST_P(Std140TestShouldRun, ArrayStorage) {
     std::string src = R"(
-@group(0) @binding(0) var<storage> s : array<${mat}<f32>, 2>;
+@group(0) @binding(0) var<storage> s : array<${mat}, 2>;
 )";
 
-    src = utils::ReplaceAll(src, "${mat}", GetParam().Mat());
+    src = GetParam().ReplaceMatInString(src);
 
     EXPECT_FALSE(ShouldRun<Std140>(src));
 }
 
 TEST_P(Std140TestShouldRun, ArrayUniform) {
-    if (GetParam().columns == 3u && GetParam().rows == 2u) {
-        // This permutation is invalid. Skip the test:
-        // error: uniform storage requires that array elements be aligned to 16 bytes, but array
-        // element alignment is currently 24. Consider wrapping the element type in a struct and
-        // using the @size attribute.
+    auto matrix = GetParam();
+
+    if (!matrix.CanBeUsedAsUniformArrayElememts()) {
+        // This permutation is invalid, skip the test.
         return;
     }
 
     std::string src = R"(
-@group(0) @binding(0) var<uniform> s : array<${mat}<f32>, 2>;
+@group(0) @binding(0) var<uniform> s : array<${mat}, 2>;
 )";
 
-    src = utils::ReplaceAll(src, "${mat}", GetParam().Mat());
+    src = GetParam().ReplaceMatInString(src);
 
-    EXPECT_EQ(ShouldRun<Std140>(src), GetParam().should_run);
+    EXPECT_EQ(ShouldRun<Std140>(src), matrix.NotStd140Compatible());
 }
 
 INSTANTIATE_TEST_SUITE_P(Std140TestShouldRun,
                          Std140TestShouldRun,
-                         ::testing::ValuesIn(std::vector<ShouldRunCase>{
-                             {2, 2, true},
-                             {2, 3, false},
-                             {2, 4, false},
-                             {3, 2, true},
-                             {3, 3, false},
-                             {3, 4, false},
-                             {4, 2, true},
-                             {4, 3, false},
-                             {4, 4, false},
+                         ::testing::ValuesIn(std::vector<MatrixCase>{
+                             {2, 2, MatrixType::f32},
+                             {2, 3, MatrixType::f32},
+                             {2, 4, MatrixType::f32},
+                             {3, 2, MatrixType::f32},
+                             {3, 3, MatrixType::f32},
+                             {3, 4, MatrixType::f32},
+                             {4, 2, MatrixType::f32},
+                             {4, 3, MatrixType::f32},
+                             {4, 4, MatrixType::f32},
                          }));
 
 TEST_F(Std140Test, EmptyModule) {
@@ -136,26 +173,137 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, SingleStructMat4x4Uniform) {
+using Std140Test_F32 = Std140Test;
+
+TEST_F(Std140Test_F32, StructMatricesUniform) {
     auto* src = R"(
-struct S {
+struct S2x2F32 {
+  m : mat2x2<f32>,
+}
+struct S3x2F32 {
+  m : mat3x2<f32>,
+}
+struct S4x2F32 {
+  m : mat4x2<f32>,
+}
+struct S2x3F32 {
+  m : mat2x3<f32>,
+}
+struct S3x3F32 {
+  m : mat3x3<f32>,
+}
+struct S4x3F32 {
+  m : mat4x3<f32>,
+}
+struct S2x4F32 {
+  m : mat2x4<f32>,
+}
+struct S3x4F32 {
+  m : mat3x4<f32>,
+}
+struct S4x4F32 {
   m : mat4x4<f32>,
 }
 
-@group(0) @binding(0) var<uniform> s : S;
+@group(2) @binding(2) var<uniform> s2x2f32 : S2x2F32;
+@group(3) @binding(2) var<uniform> s3x2f32 : S3x2F32;
+@group(4) @binding(2) var<uniform> s4x2f32 : S4x2F32;
+@group(2) @binding(3) var<uniform> s2x3f32 : S2x3F32;
+@group(3) @binding(3) var<uniform> s3x3f32 : S3x3F32;
+@group(4) @binding(3) var<uniform> s4x3f32 : S4x3F32;
+@group(2) @binding(4) var<uniform> s2x4f32 : S2x4F32;
+@group(3) @binding(4) var<uniform> s3x4f32 : S3x4F32;
+@group(4) @binding(4) var<uniform> s4x4f32 : S4x4F32;
 )";
 
-    auto* expect = src;  // Nothing violates std140 layout
+    auto* expect = R"(
+struct S2x2F32 {
+  m : mat2x2<f32>,
+}
+
+struct S2x2F32_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+}
+
+struct S3x2F32 {
+  m : mat3x2<f32>,
+}
+
+struct S3x2F32_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
+}
+
+struct S4x2F32 {
+  m : mat4x2<f32>,
+}
+
+struct S4x2F32_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
+  m_3 : vec2<f32>,
+}
+
+struct S2x3F32 {
+  m : mat2x3<f32>,
+}
+
+struct S3x3F32 {
+  m : mat3x3<f32>,
+}
+
+struct S4x3F32 {
+  m : mat4x3<f32>,
+}
+
+struct S2x4F32 {
+  m : mat2x4<f32>,
+}
+
+struct S3x4F32 {
+  m : mat3x4<f32>,
+}
+
+struct S4x4F32 {
+  m : mat4x4<f32>,
+}
+
+@group(2) @binding(2) var<uniform> s2x2f32 : S2x2F32_std140;
+
+@group(3) @binding(2) var<uniform> s3x2f32 : S3x2F32_std140;
+
+@group(4) @binding(2) var<uniform> s4x2f32 : S4x2F32_std140;
+
+@group(2) @binding(3) var<uniform> s2x3f32 : S2x3F32;
+
+@group(3) @binding(3) var<uniform> s3x3f32 : S3x3F32;
+
+@group(4) @binding(3) var<uniform> s4x3f32 : S4x3F32;
+
+@group(2) @binding(4) var<uniform> s2x4f32 : S2x4F32;
+
+@group(3) @binding(4) var<uniform> s3x4f32 : S3x4F32;
+
+@group(4) @binding(4) var<uniform> s4x4f32 : S4x4F32;
+)";
 
     auto got = Run<Std140>(src);
 
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, SingleStructMat2x2Uniform) {
+// In the following tests we only test `mat2x2<f32>` for matrix used as array element type and
+// `mat3x2<f32>` otherwise, and set all constant column index to 1, row index 0, inner array index
+// 2, and outer array index 3. For exhaustive tests, i.e. tests on all matrix shape and different
+// valid constant index, please refer to std140_exhaustive_test.cc
+
+TEST_F(Std140Test_F32, SingleStructMatUniform_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -163,12 +311,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -179,11 +328,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, CustomAlignMat3x2) {
+TEST_F(Std140Test_F32, CustomAlign_Mat3x2F32) {
     auto* src = R"(
 struct S {
   before : i32,
-  @align(128) m : mat3x2<f32>,
+  @align(128)
+  m : mat3x2<f32>,
   after : i32,
 }
 
@@ -215,11 +365,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, CustomSizeMat3x2) {
+TEST_F(Std140Test_F32, CustomSizeMat_Mat3x2F32) {
     auto* src = R"(
 struct S {
   before : i32,
-  @size(128) m : mat3x2<f32>,
+  @size(128)
+  m : mat3x2<f32>,
   after : i32,
 }
 
@@ -251,11 +402,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, CustomAlignAndSizeMat3x2) {
+TEST_F(Std140Test_F32, CustomAlignAndSize_Mat3x2F32) {
     auto* src = R"(
 struct S {
   before : i32,
-  @align(128) @size(128) m : mat3x2<f32>,
+  @align(128) @size(128)
+  m : mat3x2<f32>,
   after : i32,
 }
 
@@ -288,119 +440,54 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMatricesUniform) {
+TEST_F(Std140Test_F32, MatrixUsageInForLoop_Mat3x2F32) {
     auto* src = R"(
-struct S2x2 {
-  m : mat2x2<f32>,
-}
-struct S3x2 {
+struct S {
   m : mat3x2<f32>,
 }
-struct S4x2 {
-  m : mat4x2<f32>,
-}
-struct S2x3 {
-  m : mat2x3<f32>,
-}
-struct S3x3 {
-  m : mat3x3<f32>,
-}
-struct S4x3 {
-  m : mat4x3<f32>,
-}
-struct S2x4 {
-  m : mat2x4<f32>,
-}
-struct S3x4 {
-  m : mat3x4<f32>,
-}
-struct S4x4 {
-  m : mat4x4<f32>,
-}
 
-@group(2) @binding(2) var<uniform> s2x2 : S2x2;
-@group(3) @binding(2) var<uniform> s3x2 : S3x2;
-@group(4) @binding(2) var<uniform> s4x2 : S4x2;
-@group(2) @binding(3) var<uniform> s2x3 : S2x3;
-@group(3) @binding(3) var<uniform> s3x3 : S3x3;
-@group(4) @binding(3) var<uniform> s4x3 : S4x3;
-@group(2) @binding(4) var<uniform> s2x4 : S2x4;
-@group(3) @binding(4) var<uniform> s3x4 : S3x4;
-@group(4) @binding(4) var<uniform> s4x4 : S4x4;
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+  for(var i = u32(s.m[0][0]); (i < u32(s.m[i][1])); i += u32(s.m[1][i])) {
+  }
+}
 )";
 
     auto* expect = R"(
-struct S2x2 {
-  m : mat2x2<f32>,
-}
-
-struct S2x2_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-struct S3x2 {
+struct S {
   m : mat3x2<f32>,
 }
 
-struct S3x2_std140 {
+struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
   m_2 : vec2<f32>,
 }
 
-struct S4x2 {
-  m : mat4x2<f32>,
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_m_p0_1(p0 : u32) -> f32 {
+  switch(p0) {
+    case 0u: {
+      return s.m_0[1u];
+    }
+    case 1u: {
+      return s.m_1[1u];
+    }
+    case 2u: {
+      return s.m_2[1u];
+    }
+    default: {
+      return f32();
+    }
+  }
 }
 
-struct S4x2_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  m_2 : vec2<f32>,
-  m_3 : vec2<f32>,
+fn f() {
+  for(var i = u32(s.m_0[0u]); (i < u32(load_s_m_p0_1(u32(i)))); i += u32(s.m_1[i])) {
+  }
 }
-
-struct S2x3 {
-  m : mat2x3<f32>,
-}
-
-struct S3x3 {
-  m : mat3x3<f32>,
-}
-
-struct S4x3 {
-  m : mat4x3<f32>,
-}
-
-struct S2x4 {
-  m : mat2x4<f32>,
-}
-
-struct S3x4 {
-  m : mat3x4<f32>,
-}
-
-struct S4x4 {
-  m : mat4x4<f32>,
-}
-
-@group(2) @binding(2) var<uniform> s2x2 : S2x2_std140;
-
-@group(3) @binding(2) var<uniform> s3x2 : S3x2_std140;
-
-@group(4) @binding(2) var<uniform> s4x2 : S4x2_std140;
-
-@group(2) @binding(3) var<uniform> s2x3 : S2x3;
-
-@group(3) @binding(3) var<uniform> s3x3 : S3x3;
-
-@group(4) @binding(3) var<uniform> s4x3 : S4x3;
-
-@group(2) @binding(4) var<uniform> s2x4 : S2x4;
-
-@group(3) @binding(4) var<uniform> s3x4 : S3x4;
-
-@group(4) @binding(4) var<uniform> s4x4 : S4x4;
 )";
 
     auto got = Run<Std140>(src);
@@ -408,11 +495,345 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_NameCollision) {
+TEST_F(Std140Test_F32, MatUniform_LoadMatrix_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> m : mat3x2<f32>;
+
+fn f() {
+  let l = m;
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> m : mat3x2_f32;
+
+fn conv_mat3x2_f32(val : mat3x2_f32) -> mat3x2<f32> {
+  return mat3x2<f32>(val.col0, val.col1, val.col2);
+}
+
+fn f() {
+  let l = conv_mat3x2_f32(m);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadColumn_ConstIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let l = a[1];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn f() {
+  let l = a.col1;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadColumn_VariableIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn load_a_p0(p0 : u32) -> vec2<f32> {
+  switch(p0) {
+    case 0u: {
+      return a.col0;
+    }
+    case 1u: {
+      return a.col1;
+    }
+    case 2u: {
+      return a.col2;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0(u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadColumnSwizzle_ConstIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let l = a[1].yx;
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn f() {
+  let l = a.col1.yx;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadColumnSwizzle_VariableIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let I = 1;
+  let l = a[I].yx;
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn load_a_p0_yx(p0 : u32) -> vec2<f32> {
+  switch(p0) {
+    case 0u: {
+      return a.col0.yx;
+    }
+    case 1u: {
+      return a.col1.yx;
+    }
+    case 2u: {
+      return a.col2.yx;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_p0_yx(u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadScalar_ConstColumnIndex_ConstRowIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let l = a[1][0];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn f() {
+  let l = a.col1[0u];
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadScalar_VariableColumnIndex_ConstRowIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let I = 0;
+  let l = a[I][0];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn load_a_p0_0(p0 : u32) -> f32 {
+  switch(p0) {
+    case 0u: {
+      return a.col0[0u];
+    }
+    case 1u: {
+      return a.col1[0u];
+    }
+    case 2u: {
+      return a.col2[0u];
+    }
+    default: {
+      return f32();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_a_p0_0(u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadScalar_ConstColumnIndex_VariableRowIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let I = 0;
+  let l = a[1][I];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn f() {
+  let I = 0;
+  let l = a.col1[I];
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, MatUniform_LoadScalar_VariableColumnIndex_VariableRowIndex_Mat3x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat3x2<f32>;
+
+fn f() {
+  let I = 0;
+  let l = a[I][I];
+}
+)";
+
+    auto* expect = R"(
+struct mat3x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+  col2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat3x2_f32;
+
+fn load_a_p0_p1(p0 : u32, p1 : u32) -> f32 {
+  switch(p0) {
+    case 0u: {
+      return a.col0[p1];
+    }
+    case 1u: {
+      return a.col1[p1];
+    }
+    case 2u: {
+      return a.col2[p1];
+    }
+    default: {
+      return f32();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let l = load_a_p0_p1(u32(I), u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, StructMatUniform_NameCollision_Mat3x2F32) {
     auto* src = R"(
 struct S {
   m_1 : i32,
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -421,13 +842,14 @@
     auto* expect = R"(
 struct S {
   m_1 : i32,
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_1 : i32,
   m__0 : vec2<f32>,
   m__1 : vec2<f32>,
+  m__2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -438,10 +860,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadStruct) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadStruct_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -453,18 +875,19 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
 
 fn conv_S(val : S_std140) -> S {
-  return S(mat2x2<f32>(val.m_0, val.m_1));
+  return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
 }
 
 fn f() {
@@ -477,10 +900,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadMatrix) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadMatrix_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -492,19 +915,20 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
 
-fn load_s_m() -> mat2x2<f32> {
+fn load_s_m() -> mat3x2<f32> {
   let s = &(s);
-  return mat2x2<f32>((*(s)).m_0, (*(s)).m_1);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
 }
 
 fn f() {
@@ -517,45 +941,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadColumn0) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadColumn_ConstIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.m[0];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let l = s.m_0;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadColumn1) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -567,12 +956,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -587,10 +977,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadColumnI) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadColumn_VariableIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -603,12 +993,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -621,6 +1012,9 @@
     case 1u: {
       return s.m_1;
     }
+    case 2u: {
+      return s.m_2;
+    }
     default: {
       return vec2<f32>();
     }
@@ -638,45 +1032,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar00) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadScalar_ConstColumnIndex_ConstRowIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.m[0][0];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let l = s.m_0[0u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar10) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -688,12 +1047,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -708,10 +1068,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalarI0) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadScalar_VariableColumnIndex_ConstRowIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -724,12 +1084,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -742,6 +1103,9 @@
     case 1u: {
       return s.m_1[0u];
     }
+    case 2u: {
+      return s.m_2[0u];
+    }
     default: {
       return f32();
     }
@@ -759,168 +1123,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar01) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadScalar_ConstColumnIndex_VariableRowIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.m[0][1];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let l = s.m_0[1u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar11) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.m[1][1];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let l = s.m_1[1u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalarI1) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let I = 0;
-  let l = s.m[I][1];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn load_s_m_p0_1(p0 : u32) -> f32 {
-  switch(p0) {
-    case 0u: {
-      return s.m_0[1u];
-    }
-    case 1u: {
-      return s.m_1[1u];
-    }
-    default: {
-      return f32();
-    }
-  }
-}
-
-fn f() {
-  let I = 0;
-  let l = load_s_m_p0_1(u32(I));
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar0I) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let I = 0;
-  let l = s.m[0][I];
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  m : mat2x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let I = 0;
-  let l = s.m_0[I];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalar1I) {
-    auto* src = R"(
-struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -933,12 +1139,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -954,10 +1161,10 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructMat2x2Uniform_LoadScalarII) {
+TEST_F(Std140Test_F32, StructMatUniform_LoadScalar_VariableColumnIndex_VariableRowIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S;
@@ -970,12 +1177,13 @@
 
     auto* expect = R"(
 struct S {
-  m : mat2x2<f32>,
+  m : mat3x2<f32>,
 }
 
 struct S_std140 {
   m_0 : vec2<f32>,
   m_1 : vec2<f32>,
+  m_2 : vec2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
@@ -988,6 +1196,9 @@
     case 1u: {
       return s.m_1[p1];
     }
+    case 2u: {
+      return s.m_2[p1];
+    }
     default: {
       return f32();
     }
@@ -1005,10 +1216,11 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadArray) {
+TEST_F(Std140Test_F32, ArrayStructMatUniform_LoadArray_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
+  @size(64)
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
@@ -1055,16 +1267,17 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadStruct0) {
+TEST_F(Std140Test_F32, ArrayStructMatUniform_LoadStruct_ConstIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
+  @size(64)
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
-  let l = a[0];
+  let l = a[2];
 }
 )";
 
@@ -1088,7 +1301,7 @@
 }
 
 fn f() {
-  let l = conv_S(a[0u]);
+  let l = conv_S(a[2u]);
 }
 )";
 
@@ -1097,54 +1310,13 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadStruct1) {
+TEST_F(Std140Test_F32, ArrayStructMatUniform_LoadStruct_VariableIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S, 3>;
-
-fn f() {
-  let l = a[1];
-}
-)";
-
-    auto* expect = R"(
-struct S {
   @size(64)
   m : mat3x2<f32>,
 }
 
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
-
-fn conv_S(val : S_std140) -> S {
-  return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
-}
-
-fn f() {
-  let l = conv_S(a[1u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadStructI) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
@@ -1183,16 +1355,17 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix0) {
+TEST_F(Std140Test_F32, ArrayStructMatUniform_LoadMatrix_ConstArrayIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
+  @size(64)
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
-  let l = a[0].m;
+  let l = a[2].m;
 }
 )";
 
@@ -1211,13 +1384,13 @@
 
 @group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
 
-fn load_a_0_m() -> mat3x2<f32> {
-  let s = &(a[0u]);
+fn load_a_2_m() -> mat3x2<f32> {
+  let s = &(a[2u]);
   return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
 }
 
 fn f() {
-  let l = load_a_0_m();
+  let l = load_a_2_m();
 }
 )";
 
@@ -1226,55 +1399,13 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix1) {
+TEST_F(Std140Test_F32, ArrayStructMatUniform_LoadMatrix_VariableArrayIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S, 3>;
-
-fn f() {
-  let l = a[1].m;
-}
-)";
-
-    auto* expect = R"(
-struct S {
   @size(64)
   m : mat3x2<f32>,
 }
 
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
-
-fn load_a_1_m() -> mat3x2<f32> {
-  let s = &(a[1u]);
-  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
-}
-
-fn f() {
-  let l = load_a_1_m();
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrixI) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
@@ -1314,16 +1445,18 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix0Column0) {
+TEST_F(Std140Test_F32,
+       ArrayStructMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
+  @size(64)
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
-  let l = a[0].m[0];
+  let l = a[2].m[1];
 }
 )";
 
@@ -1343,7 +1476,7 @@
 @group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
 
 fn f() {
-  let l = a[0u].m_0;
+  let l = a[2u].m_1;
 }
 )";
 
@@ -1352,55 +1485,19 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix1Column0) {
+TEST_F(Std140Test_F32,
+       ArrayStructMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S, 3>;
-
-fn f() {
-  let l = a[1].m[0];
-}
-)";
-
-    auto* expect = R"(
-struct S {
   @size(64)
   m : mat3x2<f32>,
 }
 
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
-
-fn f() {
-  let l = a[1u].m_0;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrixIColumn0) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
   let I = 1;
-  let l = a[I].m[0];
+  let l = a[I].m[1];
 }
 )";
 
@@ -1421,7 +1518,7 @@
 
 fn f() {
   let I = 1;
-  let l = a[I].m_0;
+  let l = a[I].m_1;
 }
 )";
 
@@ -1430,16 +1527,19 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix0Column1) {
+TEST_F(Std140Test_F32,
+       ArrayStructMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
+  @size(64)
+  m : mat3x2<f32>,
 }
 
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
-  let l = a[0].m[1];
+  let I = 1;
+  let l = a[2].m[I];
 }
 )";
 
@@ -1458,8 +1558,26 @@
 
 @group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
 
+fn load_a_2_m_p0(p0 : u32) -> vec2<f32> {
+  switch(p0) {
+    case 0u: {
+      return a[2u].m_0;
+    }
+    case 1u: {
+      return a[2u].m_1;
+    }
+    case 2u: {
+      return a[2u].m_2;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
 fn f() {
-  let l = a[0u].m_1;
+  let I = 1;
+  let l = load_a_2_m_p0(u32(I));
 }
 )";
 
@@ -1468,50 +1586,14 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrix1Column1) {
+TEST_F(Std140Test_F32,
+       ArrayStructMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex_Mat3x2F32) {
     auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S, 3>;
-
-fn f() {
-  let l = a[1].m[1];
-}
-)";
-
-    auto* expect = R"(
-struct S {
   @size(64)
   m : mat3x2<f32>,
 }
 
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<S_std140, 3u>;
-
-fn f() {
-  let l = a[1u].m_1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_LoadMatrixIColumnI) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
 @group(0) @binding(0) var<uniform> a : array<S, 3>;
 
 fn f() {
@@ -1563,121 +1645,120 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, Mat4x2Uniform_LoadMatrix) {
+TEST_F(Std140Test_F32, ArrayStructArrayStructMatUniform_Loads_Mat3x2F32) {
     auto* src = R"(
-@group(0) @binding(0) var<uniform> m : mat4x2<f32>;
-
-fn f() {
-  let l = m;
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
+struct Inner {
+  @size(64)
+  m : mat3x2<f32>,
 }
 
-@group(0) @binding(0) var<uniform> m : mat4x2_f32;
-
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+struct Outer {
+  a : array<Inner, 4>,
 }
 
-fn f() {
-  let l = conv_mat4x2_f32(m);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat2x2Uniform_LoadColumn0) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
-
-fn f() {
-  let l = a[0];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat2x2_f32;
-
-fn f() {
-  let l = a.col0;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat4x2Uniform_LoadColumn1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
-
-fn f() {
-  let l = a[1];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat4x2_f32;
-
-fn f() {
-  let l = a.col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat2x2Uniform_LoadColumnI) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
+@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
 fn f() {
   let I = 1;
-
-  let l = a[I];
+  let J = 2;
+  let K = 0;
+  let l_a : array<Outer, 4> = a;
+  let l_a_1 : Outer = a[1];
+  let l_a_I : Outer = a[I];
+  let l_a_2_a : array<Inner, 4> = a[2].a;
+  let l_a_I_a : array<Inner, 4> = a[I].a;
+  let l_a_3_a_1 : Inner = a[3].a[1];
+  let l_a_3_a_I : Inner = a[3].a[I];
+  let l_a_I_a_1 : Inner = a[I].a[1];
+  let l_a_I_a_J : Inner = a[I].a[J];
+  let l_a_0_a_2_m : mat3x2<f32> = a[0].a[2].m;
+  let l_a_0_a_I_m : mat3x2<f32> = a[0].a[I].m;
+  let l_a_I_a_2_m : mat3x2<f32> = a[I].a[2].m;
+  let l_a_I_a_J_m : mat3x2<f32> = a[I].a[J].m;
+  let l_a_1_a_3_m_0 : vec2<f32> = a[1].a[3].m[0];
+  let l_a_I_a_J_m_K : vec2<f32> = a[I].a[J].m[K];
+  let l_a_2_a_0_m_1_0 : f32 = a[2].a[0].m[1][0];
+  let l_a_I_a_J_m_K_I : f32 = a[I].a[J].m[K][I];
 }
 )";
 
     auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
+struct Inner {
+  @size(64)
+  m : mat3x2<f32>,
 }
 
-@group(0) @binding(0) var<uniform> a : mat2x2_f32;
+struct Inner_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
 
-fn load_a_p0(p0 : u32) -> vec2<f32> {
-  switch(p0) {
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+struct Outer_std140 {
+  a : array<Inner_std140, 4u>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
+
+fn conv_Inner(val : Inner_std140) -> Inner {
+  return Inner(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
+}
+
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+  var arr : array<Inner, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Inner(val[i]);
+  }
+  return arr;
+}
+
+fn conv_Outer(val : Outer_std140) -> Outer {
+  return Outer(conv_arr4_Inner(val.a));
+}
+
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
+  var arr : array<Outer, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Outer(val[i]);
+  }
+  return arr;
+}
+
+fn load_a_0_a_2_m() -> mat3x2<f32> {
+  let s = &(a[0u].a[2u]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_0_a_p0_m(p0 : u32) -> mat3x2<f32> {
+  let s = &(a[0u].a[p0]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_2_m(p0 : u32) -> mat3x2<f32> {
+  let s = &(a[p0].a[2u]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_p1_m(p0 : u32, p1 : u32) -> mat3x2<f32> {
+  let s = &(a[p0].a[p1]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_p1_m_p2(p0 : u32, p1 : u32, p2 : u32) -> vec2<f32> {
+  switch(p2) {
     case 0u: {
-      return a.col0;
+      return a[p0].a[p1].m_0;
     }
     case 1u: {
-      return a.col1;
+      return a[p0].a[p1].m_1;
+    }
+    case 2u: {
+      return a[p0].a[p1].m_2;
     }
     default: {
       return vec2<f32>();
@@ -1685,157 +1766,16 @@
   }
 }
 
-fn f() {
-  let I = 1;
-  let l = load_a_p0(u32(I));
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Swizzle) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
-
-fn f() {
-  let l = a[1].yx;
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat2x2_f32;
-
-fn f() {
-  let l = a.col1.yx;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat4x2Uniform_LoadColumnISwizzle) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
-
-fn f() {
-  let I = 1;
-
-  let l = a[I].yx;
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat4x2_f32;
-
-fn load_a_p0_yx(p0 : u32) -> vec2<f32> {
-  switch(p0) {
+fn load_a_p0_a_p1_m_p2_p3(p0 : u32, p1 : u32, p2 : u32, p3 : u32) -> f32 {
+  switch(p2) {
     case 0u: {
-      return a.col0.yx;
+      return a[p0].a[p1].m_0[p3];
     }
     case 1u: {
-      return a.col1.yx;
+      return a[p0].a[p1].m_1[p3];
     }
     case 2u: {
-      return a.col2.yx;
-    }
-    case 3u: {
-      return a.col3.yx;
-    }
-    default: {
-      return vec2<f32>();
-    }
-  }
-}
-
-fn f() {
-  let I = 1;
-  let l = load_a_p0_yx(u32(I));
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Element1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
-
-fn f() {
-  let l = a[1][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat2x2_f32;
-
-fn f() {
-  let l = a.col1[1u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, Mat4x2Uniform_LoadColumnIElementI) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
-
-fn f() {
-  let I = 1;
-
-  let l = a[I][I];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : mat4x2_f32;
-
-fn load_a_p0_p1(p0 : u32, p1 : u32) -> f32 {
-  switch(p0) {
-    case 0u: {
-      return a.col0[p1];
-    }
-    case 1u: {
-      return a.col1[p1];
-    }
-    case 2u: {
-      return a.col2[p1];
-    }
-    case 3u: {
-      return a.col3[p1];
+      return a[p0].a[p1].m_2[p3];
     }
     default: {
       return f32();
@@ -1845,7 +1785,25 @@
 
 fn f() {
   let I = 1;
-  let l = load_a_p0_p1(u32(I), u32(I));
+  let J = 2;
+  let K = 0;
+  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
+  let l_a_1 : Outer = conv_Outer(a[1u]);
+  let l_a_I : Outer = conv_Outer(a[I]);
+  let l_a_2_a : array<Inner, 4> = conv_arr4_Inner(a[2u].a);
+  let l_a_I_a : array<Inner, 4> = conv_arr4_Inner(a[I].a);
+  let l_a_3_a_1 : Inner = conv_Inner(a[3u].a[1u]);
+  let l_a_3_a_I : Inner = conv_Inner(a[3u].a[I]);
+  let l_a_I_a_1 : Inner = conv_Inner(a[I].a[1u]);
+  let l_a_I_a_J : Inner = conv_Inner(a[I].a[J]);
+  let l_a_0_a_2_m : mat3x2<f32> = load_a_0_a_2_m();
+  let l_a_0_a_I_m : mat3x2<f32> = load_a_0_a_p0_m(u32(I));
+  let l_a_I_a_2_m : mat3x2<f32> = load_a_p0_a_2_m(u32(I));
+  let l_a_I_a_J_m : mat3x2<f32> = load_a_p0_a_p1_m(u32(I), u32(J));
+  let l_a_1_a_3_m_0 : vec2<f32> = a[1u].a[3u].m_0;
+  let l_a_I_a_J_m_K : vec2<f32> = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a_2_a_0_m_1_0 : f32 = a[2u].a[0u].m_1[0u];
+  let l_a_I_a_J_m_K_I : f32 = load_a_p0_a_p1_m_p2_p3(u32(I), u32(J), u32(K), u32(I));
 }
 )";
 
@@ -1854,7 +1812,492 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat2x2Uniform_LoadArray) {
+TEST_F(Std140Test_F32, ArrayStructArrayStructMatUniform_LoadsViaPtrs_Mat3x2F32) {
+    auto* src = R"(
+struct Inner {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let p_a = &(a);
+  let p_a_3 = &((*(p_a))[3]);
+  let p_a_I = &((*(p_a))[I]);
+  let p_a_3_a = &((*(p_a_3)).a);
+  let p_a_I_a = &((*(p_a_I)).a);
+  let p_a_3_a_2 = &((*(p_a_3_a))[2]);
+  let p_a_3_a_I = &((*(p_a_3_a))[I]);
+  let p_a_I_a_2 = &((*(p_a_I_a))[2]);
+  let p_a_I_a_J = &((*(p_a_I_a))[J]);
+  let p_a_3_a_2_m = &((*(p_a_3_a_2)).m);
+  let p_a_3_a_I_m = &((*(p_a_3_a_I)).m);
+  let p_a_I_a_2_m = &((*(p_a_I_a_2)).m);
+  let p_a_I_a_J_m = &((*(p_a_I_a_J)).m);
+  let p_a_3_a_2_m_1 = &((*(p_a_3_a_2_m))[1]);
+  let p_a_I_a_J_m_K = &((*(p_a_I_a_J_m))[K]);
+  let l_a : array<Outer, 4> = *(p_a);
+  let l_a_3 : Outer = *(p_a_3);
+  let l_a_I : Outer = *(p_a_I);
+  let l_a_3_a : array<Inner, 4> = *(p_a_3_a);
+  let l_a_I_a : array<Inner, 4> = *(p_a_I_a);
+  let l_a_3_a_2 : Inner = *(p_a_3_a_2);
+  let l_a_3_a_I : Inner = *(p_a_3_a_I);
+  let l_a_I_a_2 : Inner = *(p_a_I_a_2);
+  let l_a_I_a_J : Inner = *(p_a_I_a_J);
+  let l_a_3_a_2_m : mat3x2<f32> = *(p_a_3_a_2_m);
+  let l_a_3_a_I_m : mat3x2<f32> = *(p_a_3_a_I_m);
+  let l_a_I_a_2_m : mat3x2<f32> = *(p_a_I_a_2_m);
+  let l_a_I_a_J_m : mat3x2<f32> = *(p_a_I_a_J_m);
+  let l_a_3_a_2_m_1 : vec2<f32> = *(p_a_3_a_2_m_1);
+  let l_a_I_a_J_m_K : vec2<f32> = *(p_a_I_a_J_m_K);
+  let l_a_2_a_0_m_1_0 : f32 = (*(p_a_3_a_2_m_1))[0];
+  let l_a_I_a_J_m_K_I : f32 = (*(p_a_I_a_J_m_K))[I];
+}
+)";
+
+    auto* expect = R"(
+struct Inner {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct Inner_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+struct Outer_std140 {
+  a : array<Inner_std140, 4u>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
+
+fn conv_Inner(val : Inner_std140) -> Inner {
+  return Inner(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
+}
+
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+  var arr : array<Inner, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Inner(val[i]);
+  }
+  return arr;
+}
+
+fn conv_Outer(val : Outer_std140) -> Outer {
+  return Outer(conv_arr4_Inner(val.a));
+}
+
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
+  var arr : array<Outer, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_Outer(val[i]);
+  }
+  return arr;
+}
+
+fn load_a_3_a_2_m() -> mat3x2<f32> {
+  let s = &(a[3u].a[2u]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_3_a_p0_m(p0 : u32) -> mat3x2<f32> {
+  let s = &(a[3u].a[p0]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_2_m(p0 : u32) -> mat3x2<f32> {
+  let s = &(a[p0].a[2u]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_p1_m(p0 : u32, p1 : u32) -> mat3x2<f32> {
+  let s = &(a[p0].a[p1]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn load_a_p0_a_p1_m_p2(p0 : u32, p1 : u32, p2 : u32) -> vec2<f32> {
+  switch(p2) {
+    case 0u: {
+      return a[p0].a[p1].m_0;
+    }
+    case 1u: {
+      return a[p0].a[p1].m_1;
+    }
+    case 2u: {
+      return a[p0].a[p1].m_2;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn load_a_p0_a_p1_m_p2_p3(p0 : u32, p1 : u32, p2 : u32, p3 : u32) -> f32 {
+  switch(p2) {
+    case 0u: {
+      return a[p0].a[p1].m_0[p3];
+    }
+    case 1u: {
+      return a[p0].a[p1].m_1[p3];
+    }
+    case 2u: {
+      return a[p0].a[p1].m_2[p3];
+    }
+    default: {
+      return f32();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let K = 0;
+  let p_a = conv_arr4_Outer(a);
+  let p_a_3 = conv_Outer(a[3u]);
+  let p_a_I = conv_Outer(a[I]);
+  let p_a_3_a = conv_arr4_Inner(a[3u].a);
+  let p_a_I_a = conv_arr4_Inner(a[I].a);
+  let p_a_3_a_2 = conv_Inner(a[3u].a[2u]);
+  let p_a_3_a_I = conv_Inner(a[3u].a[I]);
+  let p_a_I_a_2 = conv_Inner(a[I].a[2u]);
+  let p_a_I_a_J = conv_Inner(a[I].a[J]);
+  let p_a_3_a_2_m = load_a_3_a_2_m();
+  let p_a_3_a_I_m = load_a_3_a_p0_m(u32(I));
+  let p_a_I_a_2_m = load_a_p0_a_2_m(u32(I));
+  let p_a_I_a_J_m = load_a_p0_a_p1_m(u32(I), u32(J));
+  let p_a_3_a_2_m_1 = a[3u].a[2u].m_1;
+  let p_a_I_a_J_m_K = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
+  let l_a_3 : Outer = conv_Outer(a[3u]);
+  let l_a_I : Outer = conv_Outer(a[I]);
+  let l_a_3_a : array<Inner, 4> = conv_arr4_Inner(a[3u].a);
+  let l_a_I_a : array<Inner, 4> = conv_arr4_Inner(a[I].a);
+  let l_a_3_a_2 : Inner = conv_Inner(a[3u].a[2u]);
+  let l_a_3_a_I : Inner = conv_Inner(a[3u].a[I]);
+  let l_a_I_a_2 : Inner = conv_Inner(a[I].a[2u]);
+  let l_a_I_a_J : Inner = conv_Inner(a[I].a[J]);
+  let l_a_3_a_2_m : mat3x2<f32> = load_a_3_a_2_m();
+  let l_a_3_a_I_m : mat3x2<f32> = load_a_3_a_p0_m(u32(I));
+  let l_a_I_a_2_m : mat3x2<f32> = load_a_p0_a_2_m(u32(I));
+  let l_a_I_a_J_m : mat3x2<f32> = load_a_p0_a_p1_m(u32(I), u32(J));
+  let l_a_3_a_2_m_1 : vec2<f32> = a[3u].a[2u].m_1;
+  let l_a_I_a_J_m_K : vec2<f32> = load_a_p0_a_p1_m_p2(u32(I), u32(J), u32(K));
+  let l_a_2_a_0_m_1_0 : f32 = a[3u].a[2u].m_1[0u];
+  let l_a_I_a_J_m_K_I : f32 = load_a_p0_a_p1_m_p2_p3(u32(I), u32(J), u32(K), u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyArray_UniformToStorage_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s = u;
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
+}
+
+fn conv_arr4_S(val : array<S_std140, 4u>) -> array<S, 4u> {
+  var arr : array<S, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_S(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  s = conv_arr4_S(u);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyStruct_UniformToWorkgroup_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[0] = u[1];
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+var<workgroup> w : array<S, 4>;
+
+fn conv_S(val : S_std140) -> S {
+  return S(val.v, mat3x2<f32>(val.m_0, val.m_1, val.m_2));
+}
+
+fn f() {
+  w[0] = conv_S(u[1u]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyMatrix_UniformToPrivate_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[2].m = u[1].m;
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+var<private> p : array<S, 4>;
+
+fn load_u_1_m() -> mat3x2<f32> {
+  let s = &(u[1u]);
+  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
+}
+
+fn f() {
+  p[2].m = load_u_1_m();
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyColumn_UniformToStorage_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s[3].m[1] = u[2].m[0];
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
+
+fn f() {
+  s[3].m[1] = u[2u].m_0;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyColumnSwizzle_UniformToWorkgroup_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 4>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[3].m[1] = u[2].m[0].yx.yx;
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+var<workgroup> w : array<S, 4>;
+
+fn f() {
+  w[3].m[1] = u[2u].m_0.yx.yx;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayStructMatUniform_CopyScalar_UniformToPrivate_Mat3x2F32) {
+    auto* src = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S, 3>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[3].m[1].x = u[2].m[0].y;
+}
+)";
+
+    auto* expect = R"(
+struct S {
+  v : vec4<i32>,
+  @size(64)
+  m : mat3x2<f32>,
+}
+
+struct S_std140 {
+  v : vec4<i32>,
+  m_0 : vec2<f32>,
+  m_1 : vec2<f32>,
+  @size(48)
+  m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 3u>;
+
+var<private> p : array<S, 4>;
+
+fn f() {
+  p[3].m[1].x = u[2u].m_0[1u];
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadArray_Mat2x2F32) {
     auto* src = R"(
 @group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
@@ -1893,45 +2336,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
-
-fn f() {
-  let l = a[0];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
-
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
-}
-
-fn f() {
-  let l = conv_mat4x2_f32(a[0u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1) {
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadMatrix_ConstArrayIndex_Mat2x2F32) {
     auto* src = R"(
 @group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
 fn f() {
-  let l = a[1];
+  let l = a[2];
 }
 )";
 
@@ -1948,7 +2358,7 @@
 }
 
 fn f() {
-  let l = conv_mat2x2_f32(a[1u]);
+  let l = conv_mat2x2_f32(a[2u]);
 }
 )";
 
@@ -1957,9 +2367,9 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrixI) {
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadMatrix_VariableArrayIndex_Mat2x2F32) {
     auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
 fn f() {
   let I = 1;
@@ -1968,22 +2378,20 @@
 )";
 
     auto* expect = R"(
-struct mat4x2_f32 {
+struct mat2x2_f32 {
   col0 : vec2<f32>,
   col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
 }
 
-@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
 
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
 }
 
 fn f() {
   let I = 1;
-  let l = conv_mat4x2_f32(a[I]);
+  let l = conv_mat2x2_f32(a[I]);
 }
 )";
 
@@ -1992,12 +2400,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1Column0) {
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex_Mat2x2F32) {
     auto* src = R"(
 @group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
 fn f() {
-  let l = a[1][0];
+  let l = a[2][1];
 }
 )";
 
@@ -2010,7 +2418,7 @@
 @group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
 
 fn f() {
-  let l = a[1u].col0;
+  let l = a[2u].col1;
 }
 )";
 
@@ -2019,36 +2427,7 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0Column1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
-
-fn f() {
-  let l = a[0][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
-
-fn f() {
-  let l = a[0u].col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrixIColumn1) {
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex_Mat2x2F32) {
     auto* src = R"(
 @group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
@@ -2077,39 +2456,31 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix1ColumnI) {
+TEST_F(Std140Test_F32, ArrayMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex_Mat2x2F32) {
     auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
 fn f() {
   let I = 1;
-  let l = a[1][I];
+  let l = a[2][I];
 }
 )";
 
     auto* expect = R"(
-struct mat4x2_f32 {
+struct mat2x2_f32 {
   col0 : vec2<f32>,
   col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
 }
 
-@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
 
-fn load_a_1_p0(p0 : u32) -> vec2<f32> {
+fn load_a_2_p0(p0 : u32) -> vec2<f32> {
   switch(p0) {
     case 0u: {
-      return a[1u].col0;
+      return a[2u].col0;
     }
     case 1u: {
-      return a[1u].col1;
-    }
-    case 2u: {
-      return a[1u].col2;
-    }
-    case 3u: {
-      return a[1u].col3;
+      return a[2u].col1;
     }
     default: {
       return vec2<f32>();
@@ -2119,7 +2490,7 @@
 
 fn f() {
   let I = 1;
-  let l = load_a_1_p0(u32(I));
+  let l = load_a_2_p0(u32(I));
 }
 )";
 
@@ -2128,12 +2499,14 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrays) {
+TEST_F(Std140Test_F32,
+       ArrayMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex_Mat2x2F32) {
     auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
 
 fn f() {
-  let l = a;
+  let I = 1;
+  let l = a[I][I];
 }
 )";
 
@@ -2143,307 +2516,15 @@
   col1 : vec2<f32>,
 }
 
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
 
-fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
-  return mat2x2<f32>(val.col0, val.col1);
-}
-
-fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
-  var arr : array<mat2x2<f32>, 3u>;
-  for(var i : u32; (i < 3u); i = (i + 1)) {
-    arr[i] = conv_mat2x2_f32(val[i]);
-  }
-  return arr;
-}
-
-fn conv_arr4_arr3_mat2x2_f32(val : array<array<mat2x2_f32, 3u>, 4u>) -> array<array<mat2x2<f32>, 3u>, 4u> {
-  var arr : array<array<mat2x2<f32>, 3u>, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_arr3_mat2x2_f32(val[i]);
-  }
-  return arr;
-}
-
-fn f() {
-  let l = conv_arr4_arr3_mat2x2_f32(a);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadArray0) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
-
-fn f() {
-  let l = a[0];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
-
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
-}
-
-fn conv_arr3_mat4x2_f32(val : array<mat4x2_f32, 3u>) -> array<mat4x2<f32>, 3u> {
-  var arr : array<mat4x2<f32>, 3u>;
-  for(var i : u32; (i < 3u); i = (i + 1)) {
-    arr[i] = conv_mat4x2_f32(val[i]);
-  }
-  return arr;
-}
-
-fn f() {
-  let l = conv_arr3_mat4x2_f32(a[0u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArray1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>,4>;
-
-fn f() {
-  let l = a[1];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
-
-fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
-  return mat2x2<f32>(val.col0, val.col1);
-}
-
-fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
-  var arr : array<mat2x2<f32>, 3u>;
-  for(var i : u32; (i < 3u); i = (i + 1)) {
-    arr[i] = conv_mat2x2_f32(val[i]);
-  }
-  return arr;
-}
-
-fn f() {
-  let l = conv_arr3_mat2x2_f32(a[1u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrayI) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>,4>;
-
-fn f() {
-  let I = 1;
-  let l = a[I];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
-
-fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
-  return mat2x2<f32>(val.col0, val.col1);
-}
-
-fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
-  var arr : array<mat2x2<f32>, 3u>;
-  for(var i : u32; (i < 3u); i = (i + 1)) {
-    arr[i] = conv_mat2x2_f32(val[i]);
-  }
-  return arr;
-}
-
-fn f() {
-  let I = 1;
-  let l = conv_arr3_mat2x2_f32(a[I]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrix12Column0) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
-
-fn f() {
-  let l = a[1][2][0];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
-
-fn f() {
-  let l = a[1u][2u].col0;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix2IColumn1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
-
-fn f() {
-  let I = 1;
-  let l = a[2][I][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
-
-fn f() {
-  let I = 1;
-  let l = a[2u][I].col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixI2Column1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
-
-fn f() {
-  let I = 1;
-  let l = a[I][2][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
-
-fn f() {
-  let I = 1;
-  let l = a[I][2u].col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixIIColumn1) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
-
-fn f() {
-  let I = 1;
-  let l = a[I][I][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat2x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
-
-fn f() {
-  let I = 1;
-  let l = a[I][I].col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix12ColumnI) {
-    auto* src = R"(
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
-
-fn f() {
-  let I = 1;
-  let l = a[1][2][I];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
-
-fn load_a_1_2_p0(p0 : u32) -> vec2<f32> {
-  switch(p0) {
+fn load_a_p0_p1(p0 : u32, p1 : u32) -> vec2<f32> {
+  switch(p1) {
     case 0u: {
-      return a[1u][2u].col0;
+      return a[p0].col0;
     }
     case 1u: {
-      return a[1u][2u].col1;
-    }
-    case 2u: {
-      return a[1u][2u].col2;
-    }
-    case 3u: {
-      return a[1u][2u].col3;
+      return a[p0].col1;
     }
     default: {
       return vec2<f32>();
@@ -2453,7 +2534,7 @@
 
 fn f() {
   let I = 1;
-  let l = load_a_1_2_p0(u32(I));
+  let l = load_a_p0_p1(u32(I), u32(I));
 }
 )";
 
@@ -2462,11 +2543,11 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadStruct) {
+TEST_F(Std140Test_F32, StructArrayMatUniform_LoadStruct_Mat2x2F32) {
     auto* src = R"(
 struct S {
   a : array<mat2x2<f32>, 3>,
-};
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
@@ -2517,11 +2598,11 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadArray) {
+TEST_F(Std140Test_F32, StructArrayMatUniform_LoadArray_Mat2x2F32) {
     auto* src = R"(
 struct S {
   a : array<mat2x2<f32>, 3>,
-};
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
@@ -2568,61 +2649,16 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0) {
-    auto* src = R"(
-struct S {
-  a : array<mat4x2<f32>, 3>,
-};
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.a[0];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-struct S {
-  a : array<mat4x2<f32>, 3>,
-}
-
-struct S_std140 {
-  a : array<mat4x2_f32, 3u>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
-}
-
-fn f() {
-  let l = conv_mat4x2_f32(s.a[0u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1) {
+TEST_F(Std140Test_F32, StructArrayMatUniform_LoadMatrix_ConstArrayIndex_Mat2x2F32) {
     auto* src = R"(
 struct S {
   a : array<mat2x2<f32>, 3>,
-};
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
 fn f() {
-  let l = s.a[1];
+  let l = s.a[2];
 }
 )";
 
@@ -2647,7 +2683,7 @@
 }
 
 fn f() {
-  let l = conv_mat2x2_f32(s.a[1u]);
+  let l = conv_mat2x2_f32(s.a[2u]);
 }
 )";
 
@@ -2656,11 +2692,11 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrixI) {
+TEST_F(Std140Test_F32, StructArrayMatUniform_LoadMatrix_VariableArrayIndex_Mat2x2F32) {
     auto* src = R"(
 struct S {
-  a : array<mat4x2<f32>, 3>,
-};
+  a : array<mat2x2<f32>, 3>,
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
@@ -2671,30 +2707,28 @@
 )";
 
     auto* expect = R"(
-struct mat4x2_f32 {
+struct mat2x2_f32 {
   col0 : vec2<f32>,
   col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
 }
 
 struct S {
-  a : array<mat4x2<f32>, 3>,
+  a : array<mat2x2<f32>, 3>,
 }
 
 struct S_std140 {
-  a : array<mat4x2_f32, 3u>,
+  a : array<mat2x2_f32, 3u>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
 
-fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
-  return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
 }
 
 fn f() {
   let I = 1;
-  let l = conv_mat4x2_f32(s.a[I]);
+  let l = conv_mat2x2_f32(s.a[I]);
 }
 )";
 
@@ -2703,16 +2737,17 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1Column0) {
+TEST_F(Std140Test_F32,
+       StructArrayMatUniform_LoadColumn_ConstArrayIndex_ConstColumnIndex_Mat2x2F32) {
     auto* src = R"(
 struct S {
   a : array<mat2x2<f32>, 3>,
-};
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
 fn f() {
-  let l = s.a[1][0];
+  let l = s.a[2][1];
 }
 )";
 
@@ -2733,7 +2768,7 @@
 @group(0) @binding(0) var<uniform> s : S_std140;
 
 fn f() {
-  let l = s.a[1u].col0;
+  let l = s.a[2u].col1;
 }
 )";
 
@@ -2742,52 +2777,12 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0Column1) {
-    auto* src = R"(
-struct S {
-  a : array<mat4x2<f32>, 3>,
-};
-
-@group(0) @binding(0) var<uniform> s : S;
-
-fn f() {
-  let l = s.a[0][1];
-}
-)";
-
-    auto* expect = R"(
-struct mat4x2_f32 {
-  col0 : vec2<f32>,
-  col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
-}
-
-struct S {
-  a : array<mat4x2<f32>, 3>,
-}
-
-struct S_std140 {
-  a : array<mat4x2_f32, 3u>,
-}
-
-@group(0) @binding(0) var<uniform> s : S_std140;
-
-fn f() {
-  let l = s.a[0u].col1;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrixIColumn1) {
+TEST_F(Std140Test_F32,
+       StructArrayMatUniform_LoadColumn_VariableArrayIndex_ConstColumnIndex_Mat2x2F32) {
     auto* src = R"(
 struct S {
   a : array<mat2x2<f32>, 3>,
-};
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
@@ -2824,51 +2819,44 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix1ColumnI) {
+TEST_F(Std140Test_F32,
+       StructArrayMatUniform_LoadColumn_ConstArrayIndex_VariableColumnIndex_Mat2x2F32) {
     auto* src = R"(
 struct S {
-  a : array<mat4x2<f32>, 3>,
-};
+  a : array<mat2x2<f32>, 3>,
+}
 
 @group(0) @binding(0) var<uniform> s : S;
 
 fn f() {
   let I = 1;
-  let l = s.a[1][I];
+  let l = s.a[2][I];
 }
 )";
 
     auto* expect = R"(
-struct mat4x2_f32 {
+struct mat2x2_f32 {
   col0 : vec2<f32>,
   col1 : vec2<f32>,
-  col2 : vec2<f32>,
-  col3 : vec2<f32>,
 }
 
 struct S {
-  a : array<mat4x2<f32>, 3>,
+  a : array<mat2x2<f32>, 3>,
 }
 
 struct S_std140 {
-  a : array<mat4x2_f32, 3u>,
+  a : array<mat2x2_f32, 3u>,
 }
 
 @group(0) @binding(0) var<uniform> s : S_std140;
 
-fn load_s_a_1_p0(p0 : u32) -> vec2<f32> {
+fn load_s_a_2_p0(p0 : u32) -> vec2<f32> {
   switch(p0) {
     case 0u: {
-      return s.a[1u].col0;
+      return s.a[2u].col0;
     }
     case 1u: {
-      return s.a[1u].col1;
-    }
-    case 2u: {
-      return s.a[1u].col2;
-    }
-    case 3u: {
-      return s.a[1u].col3;
+      return s.a[2u].col1;
     }
     default: {
       return vec2<f32>();
@@ -2878,7 +2866,7 @@
 
 fn f() {
   let I = 1;
-  let l = load_s_a_1_p0(u32(I));
+  let l = load_s_a_2_p0(u32(I));
 }
 )";
 
@@ -2887,536 +2875,627 @@
     EXPECT_EQ(expect, str(got));
 }
 
-TEST_F(Std140Test, ArrayStructArrayStructMat4x2Uniform_Loads) {
+TEST_F(Std140Test_F32,
+       StructArrayMatUniform_LoadColumn_VariableArrayIndex_VariableColumnIndex_Mat2x2F32) {
     auto* src = R"(
-struct Inner {
-  m : mat4x2<f32>,
+struct S {
+  a : array<mat2x2<f32>, 3>,
 }
 
-struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+@group(0) @binding(0) var<uniform> s : S;
 
 fn f() {
   let I = 1;
-
-  let l_a             : array<Outer, 4>  = a;
-  let l_a_1           : Outer            = a[1];
-  let l_a_2_a         : array<Inner, 4>  = a[2].a;
-  let l_a_3_a_1       : Inner            = a[3].a[1];
-  let l_a_0_a_2_m     : mat4x2<f32>      = a[0].a[2].m;
-  let l_a_1_a_3_m_0   : vec2<f32>        = a[1].a[3].m[0];
-  let l_a_2_a_0_m_1_0 : f32              = a[2].a[0].m[1][0];
+  let l = s.a[I][I];
 }
 )";
 
     auto* expect = R"(
-struct Inner {
-  m : mat4x2<f32>,
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
 }
 
-struct Inner_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  m_2 : vec2<f32>,
-  m_3 : vec2<f32>,
-}
-
-struct Outer {
-  a : array<Inner, 4>,
-}
-
-struct Outer_std140 {
-  a : array<Inner_std140, 4u>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
-
-fn conv_Inner(val : Inner_std140) -> Inner {
-  return Inner(mat4x2<f32>(val.m_0, val.m_1, val.m_2, val.m_3));
-}
-
-fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
-  var arr : array<Inner, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_Inner(val[i]);
-  }
-  return arr;
-}
-
-fn conv_Outer(val : Outer_std140) -> Outer {
-  return Outer(conv_arr4_Inner(val.a));
-}
-
-fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
-  var arr : array<Outer, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_Outer(val[i]);
-  }
-  return arr;
-}
-
-fn load_a_0_a_2_m() -> mat4x2<f32> {
-  let s = &(a[0u].a[2u]);
-  return mat4x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2, (*(s)).m_3);
-}
-
-fn f() {
-  let I = 1;
-  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
-  let l_a_1 : Outer = conv_Outer(a[1u]);
-  let l_a_2_a : array<Inner, 4> = conv_arr4_Inner(a[2u].a);
-  let l_a_3_a_1 : Inner = conv_Inner(a[3u].a[1u]);
-  let l_a_0_a_2_m : mat4x2<f32> = load_a_0_a_2_m();
-  let l_a_1_a_3_m_0 : vec2<f32> = a[1u].a[3u].m_0;
-  let l_a_2_a_0_m_1_0 : f32 = a[2u].a[0u].m_1[0u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructArrayStructMat4x2Uniform_LoadsViaPtrs) {
-    // Note: Std140Test requires the PromoteSideEffectsToDecl transform to have been run first, so
-    // side-effects in the let-chain will not be a problem.
-    auto* src = R"(
-struct Inner {
-  m : mat4x2<f32>,
-}
-
-struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
-
-fn f() {
-  let I = 1;
-
-  let p_a = &a;
-  let p_a_3 = &((*p_a)[3]);
-  let p_a_3_a = &((*p_a_3).a);
-  let p_a_3_a_2 = &((*p_a_3_a)[2]);
-  let p_a_3_a_2_m = &((*p_a_3_a_2).m);
-  let p_a_3_a_2_m_1 = &((*p_a_3_a_2_m)[1]);
-
-
-  let l_a             : array<Outer, 4> = *p_a;
-  let l_a_3           : Outer           = *p_a_3;
-  let l_a_3_a         : array<Inner, 4> = *p_a_3_a;
-  let l_a_3_a_2       : Inner           = *p_a_3_a_2;
-  let l_a_3_a_2_m     : mat4x2<f32>     = *p_a_3_a_2_m;
-  let l_a_3_a_2_m_1   : vec2<f32>       = *p_a_3_a_2_m_1;
-  let l_a_2_a_0_m_1_0 : f32             = (*p_a_3_a_2_m_1)[0];
-}
-)";
-
-    auto* expect = R"(
-struct Inner {
-  m : mat4x2<f32>,
-}
-
-struct Inner_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  m_2 : vec2<f32>,
-  m_3 : vec2<f32>,
-}
-
-struct Outer {
-  a : array<Inner, 4>,
-}
-
-struct Outer_std140 {
-  a : array<Inner_std140, 4u>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer_std140, 4u>;
-
-fn conv_Inner(val : Inner_std140) -> Inner {
-  return Inner(mat4x2<f32>(val.m_0, val.m_1, val.m_2, val.m_3));
-}
-
-fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
-  var arr : array<Inner, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_Inner(val[i]);
-  }
-  return arr;
-}
-
-fn conv_Outer(val : Outer_std140) -> Outer {
-  return Outer(conv_arr4_Inner(val.a));
-}
-
-fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
-  var arr : array<Outer, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_Outer(val[i]);
-  }
-  return arr;
-}
-
-fn load_a_3_a_2_m() -> mat4x2<f32> {
-  let s = &(a[3u].a[2u]);
-  return mat4x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2, (*(s)).m_3);
-}
-
-fn f() {
-  let I = 1;
-  let p_a = conv_arr4_Outer(a);
-  let p_a_3 = conv_Outer(a[3u]);
-  let p_a_3_a = conv_arr4_Inner(a[3u].a);
-  let p_a_3_a_2 = conv_Inner(a[3u].a[2u]);
-  let p_a_3_a_2_m = load_a_3_a_2_m();
-  let p_a_3_a_2_m_1 = a[3u].a[2u].m_1;
-  let l_a : array<Outer, 4> = conv_arr4_Outer(a);
-  let l_a_3 : Outer = conv_Outer(a[3u]);
-  let l_a_3_a : array<Inner, 4> = conv_arr4_Inner(a[3u].a);
-  let l_a_3_a_2 : Inner = conv_Inner(a[3u].a[2u]);
-  let l_a_3_a_2_m : mat4x2<f32> = load_a_3_a_2_m();
-  let l_a_3_a_2_m_1 : vec2<f32> = a[3u].a[2u].m_1;
-  let l_a_2_a_0_m_1_0 : f32 = a[3u].a[2u].m_1[0u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopyArray_UniformToStorage) {
-    auto* src = R"(
 struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
-
-fn f() {
-    s = u;
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  @size(64)
-  m : mat3x2<f32>,
+  a : array<mat2x2<f32>, 3>,
 }
 
 struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
+  a : array<mat2x2_f32, 3u>,
 }
 
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+@group(0) @binding(0) var<uniform> s : S_std140;
 
-@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
-
-fn conv_S(val : S_std140) -> S {
-  return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
-}
-
-fn conv_arr4_S(val : array<S_std140, 4u>) -> array<S, 4u> {
-  var arr : array<S, 4u>;
-  for(var i : u32; (i < 4u); i = (i + 1)) {
-    arr[i] = conv_S(val[i]);
-  }
-  return arr;
-}
-
-fn f() {
-  s = conv_arr4_S(u);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopyStruct_UniformToWorkgroup) {
-    auto* src = R"(
-struct S {
-  v : vec4<i32>,
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-var<workgroup> w : array<S, 4>;
-
-fn f() {
-    w[0] = u[1];
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  v : vec4<i32>,
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  v : vec4<i32>,
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
-
-var<workgroup> w : array<S, 4>;
-
-fn conv_S(val : S_std140) -> S {
-  return S(val.v, mat3x2<f32>(val.m_0, val.m_1, val.m_2));
-}
-
-fn f() {
-  w[0] = conv_S(u[1u]);
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopyMatrix_UniformToPrivate) {
-    auto* src = R"(
-struct S {
-  v : vec4<i32>,
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-var<private> p : array<S, 4>;
-
-fn f() {
-    p[2].m = u[1].m;
-}
-)";
-
-    auto* expect = R"(
-struct S {
-  v : vec4<i32>,
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  v : vec4<i32>,
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
-
-var<private> p : array<S, 4>;
-
-fn load_u_1_m() -> mat3x2<f32> {
-  let s = &(u[1u]);
-  return mat3x2<f32>((*(s)).m_0, (*(s)).m_1, (*(s)).m_2);
-}
-
-fn f() {
-  p[2].m = load_u_1_m();
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopyColumn_UniformToStorage) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
-
-fn f() {
-    s[3].m[1] = u[2].m[0];
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
-
-@group(0) @binding(1) var<storage, read_write> s : array<S, 4>;
-
-fn f() {
-  s[3].m[1] = u[2u].m_0;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopySwizzle_UniformToWorkgroup) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-var<workgroup> w : array<S, 4>;
-
-fn f() {
-    w[3].m[1] = u[2].m[0].yx.xy;
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
-
-var<workgroup> w : array<S, 4>;
-
-fn f() {
-  w[3].m[1] = u[2u].m_0.yx.xy;
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, ArrayStructMat3x2Uniform_CopyScalar_UniformToPrivate) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S, 4>;
-var<private> w : array<S, 4>;
-
-fn f() {
-    w[3].m[1].x = u[2].m[0].y;
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
-
-var<private> w : array<S, 4>;
-
-fn f() {
-  w[3].m[1].x = u[2u].m_0[1u];
-}
-)";
-
-    auto got = Run<Std140>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(Std140Test, MatrixUsageInForLoop) {
-    auto* src = R"(
-struct S {
-  @size(64) m : mat3x2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : S;
-
-fn f() {
-    for (var i = u32(u.m[0][0]); i < u32(u.m[i][1]); i += u32(u.m[1][i])) {
-    }
-}
-)";
-
-    auto* expect =
-        R"(
-struct S {
-  @size(64)
-  m : mat3x2<f32>,
-}
-
-struct S_std140 {
-  m_0 : vec2<f32>,
-  m_1 : vec2<f32>,
-  @size(48)
-  m_2 : vec2<f32>,
-}
-
-@group(0) @binding(0) var<uniform> u : S_std140;
-
-fn load_u_m_p0_1(p0 : u32) -> f32 {
-  switch(p0) {
+fn load_s_a_p0_p1(p0 : u32, p1 : u32) -> vec2<f32> {
+  switch(p1) {
     case 0u: {
-      return u.m_0[1u];
+      return s.a[p0].col0;
     }
     case 1u: {
-      return u.m_1[1u];
-    }
-    case 2u: {
-      return u.m_2[1u];
+      return s.a[p0].col1;
     }
     default: {
-      return f32();
+      return vec2<f32>();
     }
   }
 }
 
 fn f() {
-  for(var i = u32(u.m_0[0u]); (i < u32(load_u_m_p0_1(u32(i)))); i += u32(u.m_1[i])) {
+  let I = 1;
+  let l = load_s_a_p0_p1(u32(I), u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayArrayMatUniform_LoadArrays_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let l = a;
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+  var arr : array<mat2x2<f32>, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat2x2_f32(val[i]);
   }
+  return arr;
+}
+
+fn conv_arr4_arr3_mat2x2_f32(val : array<array<mat2x2_f32, 3u>, 4u>) -> array<array<mat2x2<f32>, 3u>, 4u> {
+  var arr : array<array<mat2x2<f32>, 3u>, 4u>;
+  for(var i : u32; (i < 4u); i = (i + 1)) {
+    arr[i] = conv_arr3_mat2x2_f32(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr4_arr3_mat2x2_f32(a);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayArrayMatUniform_LoadArray_ConstOuterArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let l = a[3];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+  var arr : array<mat2x2<f32>, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat2x2_f32(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let l = conv_arr3_mat2x2_f32(a[3u]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32, ArrayArrayMatUniform_LoadArray_VariableOuterArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+  var arr : array<mat2x2<f32>, 3u>;
+  for(var i : u32; (i < 3u); i = (i + 1)) {
+    arr[i] = conv_mat2x2_f32(val[i]);
+  }
+  return arr;
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_arr3_mat2x2_f32(a[I]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32,
+       ArrayArrayMatUniform_LoadMatrix_ConstOuterArrayIndex_ConstInnerArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let l = a[3][2];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+  let l = conv_mat2x2_f32(a[3u][2u]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32,
+       ArrayArrayMatUniform_LoadMatrix_ConstOuterArrayIndex_VariableInnerArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[3][I];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat2x2_f32(a[3u][I]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32,
+       ArrayArrayMatUniform_LoadMatrix_VariableOuterArrayIndex_ConstInnerArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][2];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat2x2_f32(a[I][2u]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test_F32,
+       ArrayArrayMatUniform_LoadMatrix_VariableOuterArrayIndex_VariableInnerArrayIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][I];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+  return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+  let I = 1;
+  let l = conv_mat2x2_f32(a[I][I]);
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_ConstInnerArrayIndex_ConstColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let l = a[3][2][1];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+  let l = a[3u][2u].col1;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_ConstInnerArrayIndex_VariableColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[3][2][I];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn load_a_3_2_p0(p0 : u32) -> vec2<f32> {
+  switch(p0) {
+    case 0u: {
+      return a[3u][2u].col0;
+    }
+    case 1u: {
+      return a[3u][2u].col1;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let l = load_a_3_2_p0(u32(I));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_VariableInnerArrayIndex_ConstColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[3][I][1];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let l = a[3u][I].col1;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_ConstOuterArrayIndex_VariableInnerArrayIndex_VariableColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[3][I][J];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn load_a_3_p0_p1(p0 : u32, p1 : u32) -> vec2<f32> {
+  switch(p1) {
+    case 0u: {
+      return a[3u][p0].col0;
+    }
+    case 1u: {
+      return a[3u][p0].col1;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = load_a_3_p0_p1(u32(I), u32(J));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_ConstInnerArrayIndex_ConstColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][2][1];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let l = a[I][2u].col1;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_ConstInnerArrayIndex_VariableColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][2][J];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn load_a_p0_2_p1(p0 : u32, p1 : u32) -> vec2<f32> {
+  switch(p1) {
+    case 0u: {
+      return a[p0][2u].col0;
+    }
+    case 1u: {
+      return a[p0][2u].col1;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = load_a_p0_2_p1(u32(I), u32(J));
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_VariableInnerArrayIndex_ConstColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][J][1];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+  let I = 1;
+  let J = 2;
+  let l = a[I][J].col1;
+}
+)";
+
+    auto got = Run<Std140>(src);
+
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(
+    Std140Test_F32,
+    ArrayArrayMatUniform_LoadColumn_VariableOuterArrayIndex_VariableInnerArrayIndex_VariableColumnIndex_Mat2x2F32) {
+    auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+  let I = 0;
+  let J = 1;
+  let K = 2;
+  let l = a[I][J][K];
+}
+)";
+
+    auto* expect = R"(
+struct mat2x2_f32 {
+  col0 : vec2<f32>,
+  col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn load_a_p0_p1_p2(p0 : u32, p1 : u32, p2 : u32) -> vec2<f32> {
+  switch(p2) {
+    case 0u: {
+      return a[p0][p1].col0;
+    }
+    case 1u: {
+      return a[p0][p1].col1;
+    }
+    default: {
+      return vec2<f32>();
+    }
+  }
+}
+
+fn f() {
+  let I = 0;
+  let J = 1;
+  let K = 2;
+  let l = load_a_p0_p1_p2(u32(I), u32(J), u32(K));
 }
 )";
 
diff --git a/src/tint/utils/string.cc b/src/tint/utils/string.cc
new file mode 100644
index 0000000..a0d3b85
--- /dev/null
+++ b/src/tint/utils/string.cc
@@ -0,0 +1,51 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <algorithm>
+
+#include "src/tint/utils/string.h"
+#include "src/tint/utils/vector.h"
+
+namespace tint::utils {
+
+size_t Distance(const std::string& str_a, const std::string& str_b) {
+    const auto len_a = str_a.size();
+    const auto len_b = str_b.size();
+
+    Vector<size_t, 64> mat;
+    mat.Reserve((len_a + 1) * (len_b + 1));
+
+    auto at = [&](size_t a, size_t b) -> size_t& { return mat[a + b * (len_a + 1)]; };
+
+    at(0, 0) = 0;
+    for (size_t a = 1; a <= len_a; a++) {
+        at(a, 0) = a;
+    }
+    for (size_t b = 1; b <= len_b; b++) {
+        at(0, b) = b;
+    }
+    for (size_t b = 1; b <= len_b; b++) {
+        for (size_t a = 1; a <= len_a; a++) {
+            bool eq = str_a[a - 1] == str_b[b - 1];
+            at(a, b) = std::min({
+                at(a - 1, b) + 1,
+                at(a, b - 1) + 1,
+                at(a - 1, b - 1) + (eq ? 0 : 1),
+            });
+        }
+    }
+    return at(len_a, len_b);
+}
+
+}  // namespace tint::utils
diff --git a/src/tint/utils/string.h b/src/tint/utils/string.h
index de1f4d6..9f65395 100644
--- a/src/tint/utils/string.h
+++ b/src/tint/utils/string.h
@@ -44,6 +44,11 @@
     return s.str();
 }
 
+/// @param a the first string
+/// @param b the second string
+/// @returns the Levenshtein distance between @p a and @p b
+size_t Distance(const std::string& a, const std::string& b);
+
 }  // namespace tint::utils
 
 #endif  // SRC_TINT_UTILS_STRING_H_
diff --git a/src/tint/utils/string_test.cc b/src/tint/utils/string_test.cc
index d1cab51..6c8008c 100644
--- a/src/tint/utils/string_test.cc
+++ b/src/tint/utils/string_test.cc
@@ -20,21 +20,33 @@
 namespace {
 
 TEST(StringTest, ReplaceAll) {
-    ASSERT_EQ("xybbcc", ReplaceAll("aabbcc", "aa", "xy"));
-    ASSERT_EQ("aaxycc", ReplaceAll("aabbcc", "bb", "xy"));
-    ASSERT_EQ("aabbxy", ReplaceAll("aabbcc", "cc", "xy"));
-    ASSERT_EQ("xyxybbcc", ReplaceAll("aabbcc", "a", "xy"));
-    ASSERT_EQ("aaxyxycc", ReplaceAll("aabbcc", "b", "xy"));
-    ASSERT_EQ("aabbxyxy", ReplaceAll("aabbcc", "c", "xy"));
+    EXPECT_EQ("xybbcc", ReplaceAll("aabbcc", "aa", "xy"));
+    EXPECT_EQ("aaxycc", ReplaceAll("aabbcc", "bb", "xy"));
+    EXPECT_EQ("aabbxy", ReplaceAll("aabbcc", "cc", "xy"));
+    EXPECT_EQ("xyxybbcc", ReplaceAll("aabbcc", "a", "xy"));
+    EXPECT_EQ("aaxyxycc", ReplaceAll("aabbcc", "b", "xy"));
+    EXPECT_EQ("aabbxyxy", ReplaceAll("aabbcc", "c", "xy"));
     // Replacement string includes the searched-for string.
     // This proves that the algorithm needs to advance 'pos'
     // past the replacement.
-    ASSERT_EQ("aabxybbxybcc", ReplaceAll("aabbcc", "b", "bxyb"));
+    EXPECT_EQ("aabxybbxybcc", ReplaceAll("aabbcc", "b", "bxyb"));
 }
 
 TEST(StringTest, ToString) {
-    ASSERT_EQ("123", ToString(123));
-    ASSERT_EQ("hello", ToString("hello"));
+    EXPECT_EQ("123", ToString(123));
+    EXPECT_EQ("hello", ToString("hello"));
+}
+
+TEST(StringTest, Distance) {
+    EXPECT_EQ(Distance("hello world", "hello world"), 0u);
+    EXPECT_EQ(Distance("hello world", "helloworld"), 1u);
+    EXPECT_EQ(Distance("helloworld", "hello world"), 1u);
+    EXPECT_EQ(Distance("hello world", "hello  world"), 1u);
+    EXPECT_EQ(Distance("hello  world", "hello world"), 1u);
+    EXPECT_EQ(Distance("Hello World", "hello world"), 2u);
+    EXPECT_EQ(Distance("hello world", "Hello World"), 2u);
+    EXPECT_EQ(Distance("Hello world", ""), 11u);
+    EXPECT_EQ(Distance("", "Hello world"), 11u);
 }
 
 }  // namespace
diff --git a/src/tint/utils/vector.h b/src/tint/utils/vector.h
index f0cbf58..705817a 100644
--- a/src/tint/utils/vector.h
+++ b/src/tint/utils/vector.h
@@ -463,13 +463,15 @@
     /// Equality operator
     /// @param other the other vector
     /// @returns true if this vector is the same length as `other`, and all elements are equal.
-    bool operator==(const Vector& other) const {
+    template <typename T2, size_t N2>
+    bool operator==(const Vector<T2, N2>& other) const {
         const size_t len = Length();
-        if (len == other.Length()) {
-            for (size_t i = 0; i < len; i++) {
-                if ((*this)[i] != other[i]) {
-                    return false;
-                }
+        if (len != other.Length()) {
+            return false;
+        }
+        for (size_t i = 0; i < len; i++) {
+            if ((*this)[i] != other[i]) {
+                return false;
             }
         }
         return true;
@@ -479,7 +481,10 @@
     /// @param other the other vector
     /// @returns true if this vector is not the same length as `other`, or all elements are not
     ///          equal.
-    bool operator!=(const Vector& other) const { return !(*this == other); }
+    template <typename T2, size_t N2>
+    bool operator!=(const Vector<T2, N2>& other) const {
+        return !(*this == other);
+    }
 
   private:
     /// Friend class (differing specializations of this class)
diff --git a/src/tint/utils/vector_test.cc b/src/tint/utils/vector_test.cc
index b4e9fb5..a3cc1f7 100644
--- a/src/tint/utils/vector_test.cc
+++ b/src/tint/utils/vector_test.cc
@@ -2060,6 +2060,15 @@
     EXPECT_EQ(vec_ref.end(), &vec[0] + 3);
 }
 
+TEST(TintVectorTest, Equality) {
+    EXPECT_EQ((Vector<int, 2>{1, 2}), (Vector<int, 2>{1, 2}));
+    EXPECT_EQ((Vector<int, 1>{1, 2}), (Vector<int, 3>{1, 2}));
+    EXPECT_NE((Vector{1, 2}), (Vector{1}));
+    EXPECT_NE((Vector{1}), (Vector{1, 2}));
+    EXPECT_NE((Vector{1, 2}), (Vector{2, 1}));
+    EXPECT_NE((Vector{2, 1}), (Vector{1, 2}));
+}
+
 }  // namespace
 }  // namespace tint::utils
 
diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc
index edf9132..98e9efc 100644
--- a/src/tint/writer/append_vector.cc
+++ b/src/tint/writer/append_vector.cc
@@ -137,7 +137,7 @@
         auto* scalar_cast_target = b->create<sem::TypeConversion>(
             packed_el_sem_ty,
             b->create<sem::Parameter>(nullptr, 0u, scalar_sem->Type()->UnwrapRef(),
-                                      ast::AddressSpace::kNone, ast::Access::kUndefined),
+                                      ast::AddressSpace::kNone, ast::Access::kInvalid),
             sem::EvaluationStage::kRuntime);
         auto* scalar_cast_sem = b->create<sem::Call>(
             scalar_cast_ast, scalar_cast_target, sem::EvaluationStage::kRuntime,
@@ -158,7 +158,7 @@
                          [&](const tint::sem::Expression* arg, size_t i) -> const sem::Parameter* {
                              return b->create<sem::Parameter>(
                                  nullptr, static_cast<uint32_t>(i), arg->Type()->UnwrapRef(),
-                                 ast::AddressSpace::kNone, ast::Access::kUndefined);
+                                 ast::AddressSpace::kNone, ast::Access::kInvalid);
                          }),
         sem::EvaluationStage::kRuntime);
     auto* constructor_sem =
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 429249d..da67b3d 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -509,20 +509,20 @@
                                 {
                                     auto decl = line(&b);
                                     if (!EmitTypeAndName(decl, ret_ty, ast::AddressSpace::kNone,
-                                                         ast::Access::kUndefined, fn_name)) {
+                                                         ast::Access::kInvalid, fn_name)) {
                                         return "";
                                     }
                                     {
                                         ScopedParen sp(decl);
                                         const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
                                         if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone,
-                                                             ast::Access::kUndefined, "lhs")) {
+                                                             ast::Access::kInvalid, "lhs")) {
                                             return "";
                                         }
                                         decl << ", ";
                                         ty = TypeOf(expr->rhs)->UnwrapRef();
                                         if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone,
-                                                             ast::Access::kUndefined, "rhs")) {
+                                                             ast::Access::kInvalid, "rhs")) {
                                             return "";
                                         }
                                     }
@@ -935,7 +935,7 @@
             {
                 auto pre = line();
                 if (!EmitTypeAndName(pre, builtin->ReturnType(), ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, result)) {
+                                     ast::Access::kInvalid, result)) {
                     return false;
                 }
                 pre << ";";
@@ -1213,7 +1213,7 @@
             {
                 auto l = line(b);
                 if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone,
-                              ast::Access::kUndefined, "")) {
+                              ast::Access::kInvalid, "")) {
                     return false;
                 }
                 l << " result;";
@@ -1239,7 +1239,7 @@
             {
                 auto l = line(b);
                 if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone,
-                              ast::Access::kUndefined, "")) {
+                              ast::Access::kInvalid, "")) {
                     return false;
                 }
                 l << " result;";
@@ -2049,6 +2049,7 @@
             switch (interpolate->type) {
                 case ast::InterpolationType::kPerspective:
                 case ast::InterpolationType::kLinear:
+                case ast::InterpolationType::kInvalid:
                     break;
                 case ast::InterpolationType::kFlat:
                     out << "flat ";
@@ -2060,7 +2061,7 @@
                     break;
                 case ast::InterpolationSampling::kSample:
                 case ast::InterpolationSampling::kCenter:
-                case ast::InterpolationSampling::kNone:
+                case ast::InterpolationSampling::kInvalid:
                     break;
             }
         }
@@ -2197,7 +2198,7 @@
             return true;
         },
         [&](const sem::Vector* v) {
-            if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -2218,7 +2219,7 @@
             return true;
         },
         [&](const sem::Matrix* m) {
-            if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -2235,7 +2236,7 @@
             return true;
         },
         [&](const sem::Array* a) {
-            if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -2259,7 +2260,7 @@
             return true;
         },
         [&](const sem::Struct* s) {
-            if (!EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -2350,7 +2351,7 @@
             }
         }
     } else if (auto* str = type->As<sem::Struct>()) {
-        if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+        if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
             return false;
         }
         bool first = true;
@@ -2364,7 +2365,7 @@
             EmitZeroValue(out, member->Type());
         }
     } else if (auto* arr = type->As<sem::Array>()) {
-        if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+        if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
             return false;
         }
         ScopedParen sp(out);
@@ -2971,7 +2972,7 @@
 
     auto out = line();
     // TODO(senorblanco): handle const
-    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined,
+    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid,
                          builder_.Symbols().NameFor(let->symbol))) {
         return false;
     }
@@ -2993,7 +2994,7 @@
 
     auto out = line();
     out << "const ";
-    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined,
+    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid,
                          builder_.Symbols().NameFor(var->symbol))) {
         return false;
     }
@@ -3021,7 +3022,7 @@
         {
             auto decl = line(&b);
             if (!EmitTypeAndName(decl, builtin->ReturnType(), ast::AddressSpace::kNone,
-                                 ast::Access::kUndefined, fn_name)) {
+                                 ast::Access::kInvalid, fn_name)) {
                 return "";
             }
             {
@@ -3036,8 +3037,8 @@
                         decl << "inout ";
                         ty = ptr->StoreType();
                     }
-                    if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone,
-                                         ast::Access::kUndefined, param_name)) {
+                    if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                         param_name)) {
                         return "";
                     }
                     parameter_names.emplace_back(std::move(param_name));
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 4ada084..94e80e8 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -325,8 +325,7 @@
         std::string fn;
         {
             std::ostringstream ss;
-            if (!EmitType(ss, vec, tint::ast::AddressSpace::kInvalid, ast::Access::kUndefined,
-                          "")) {
+            if (!EmitType(ss, vec, tint::ast::AddressSpace::kInvalid, ast::Access::kInvalid, "")) {
                 return "";
             }
             fn = UniqueIdentifier("set_" + ss.str());
@@ -334,13 +333,13 @@
         {
             auto out = line(&helpers_);
             out << "void " << fn << "(inout ";
-            if (!EmitTypeAndName(out, vec, ast::AddressSpace::kInvalid, ast::Access::kUndefined,
+            if (!EmitTypeAndName(out, vec, ast::AddressSpace::kInvalid, ast::Access::kInvalid,
                                  "vec")) {
                 return "";
             }
             out << ", int idx, ";
             if (!EmitTypeAndName(out, vec->type(), ast::AddressSpace::kInvalid,
-                                 ast::Access::kUndefined, "val")) {
+                                 ast::Access::kInvalid, "val")) {
                 return "";
             }
             out << ") {";
@@ -399,8 +398,7 @@
         std::string fn;
         {
             std::ostringstream ss;
-            if (!EmitType(ss, mat, tint::ast::AddressSpace::kInvalid, ast::Access::kUndefined,
-                          "")) {
+            if (!EmitType(ss, mat, tint::ast::AddressSpace::kInvalid, ast::Access::kInvalid, "")) {
                 return "";
             }
             fn = UniqueIdentifier("set_vector_" + ss.str());
@@ -408,13 +406,13 @@
         {
             auto out = line(&helpers_);
             out << "void " << fn << "(inout ";
-            if (!EmitTypeAndName(out, mat, ast::AddressSpace::kInvalid, ast::Access::kUndefined,
+            if (!EmitTypeAndName(out, mat, ast::AddressSpace::kInvalid, ast::Access::kInvalid,
                                  "mat")) {
                 return "";
             }
             out << ", int col, ";
             if (!EmitTypeAndName(out, mat->ColumnType(), ast::AddressSpace::kInvalid,
-                                 ast::Access::kUndefined, "val")) {
+                                 ast::Access::kInvalid, "val")) {
                 return "";
             }
             out << ") {";
@@ -468,8 +466,7 @@
         std::string fn;
         {
             std::ostringstream ss;
-            if (!EmitType(ss, mat, tint::ast::AddressSpace::kInvalid, ast::Access::kUndefined,
-                          "")) {
+            if (!EmitType(ss, mat, tint::ast::AddressSpace::kInvalid, ast::Access::kInvalid, "")) {
                 return "";
             }
             fn = UniqueIdentifier("set_scalar_" + ss.str());
@@ -477,13 +474,13 @@
         {
             auto out = line(&helpers_);
             out << "void " << fn << "(inout ";
-            if (!EmitTypeAndName(out, mat, ast::AddressSpace::kInvalid, ast::Access::kUndefined,
+            if (!EmitTypeAndName(out, mat, ast::AddressSpace::kInvalid, ast::Access::kInvalid,
                                  "mat")) {
                 return "";
             }
             out << ", int col, int row, ";
             if (!EmitTypeAndName(out, mat->type(), ast::AddressSpace::kInvalid,
-                                 ast::Access::kUndefined, "val")) {
+                                 ast::Access::kInvalid, "val")) {
                 return "";
             }
             out << ") {";
@@ -658,7 +655,7 @@
         if (auto* vec = ty->As<sem::Vector>()) {
             auto* elem_ty = vec->type();
 
-            if (!EmitType(out, ty, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, ty, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -723,7 +720,7 @@
         std::string ty_name;
         {
             std::ostringstream ss;
-            if (!EmitType(ss, ty, tint::ast::AddressSpace::kInvalid, ast::Access::kUndefined, "")) {
+            if (!EmitType(ss, ty, tint::ast::AddressSpace::kInvalid, ast::Access::kInvalid, "")) {
                 return "";
             }
             ty_name = ss.str();
@@ -1431,12 +1428,12 @@
     auto rmw = [&](const char* hlsl) -> bool {
         {
             auto fn = line(&buf);
-            if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
+            if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
                                  name)) {
                 return false;
             }
             fn << "(RWByteAddressBuffer buffer, uint offset, ";
-            if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
+            if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
                                  "value")) {
                 return false;
             }
@@ -1452,7 +1449,7 @@
 
         {
             auto l = line(&buf);
-            if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
+            if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
                                  "original_value")) {
                 return false;
             }
@@ -1501,8 +1498,8 @@
             // InterlockedOr using 0 as the OR value
             {
                 auto fn = line(&buf);
-                if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, name)) {
+                if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     name)) {
                     return false;
                 }
                 fn << "(RWByteAddressBuffer buffer, uint offset) {";
@@ -1517,8 +1514,8 @@
 
             {
                 auto l = line(&buf);
-                if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, "value")) {
+                if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     "value")) {
                     return false;
                 }
                 l << " = 0;";
@@ -1535,8 +1532,8 @@
             {
                 auto fn = line(&buf);
                 fn << "void " << name << "(RWByteAddressBuffer buffer, uint offset, ";
-                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, "value")) {
+                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     "value")) {
                     return false;
                 }
                 fn << ") {";
@@ -1551,7 +1548,7 @@
 
             {
                 auto l = line(&buf);
-                if (!EmitTypeAndName(l, value_ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
+                if (!EmitTypeAndName(l, value_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
                                      "ignored")) {
                     return false;
                 }
@@ -1566,18 +1563,18 @@
             auto* value_ty = params[2]->Type()->UnwrapRef();
             {
                 auto fn = line(&buf);
-                if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, name)) {
+                if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     name)) {
                     return false;
                 }
                 fn << "(RWByteAddressBuffer buffer, uint offset, ";
-                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, "compare")) {
+                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     "compare")) {
                     return false;
                 }
                 fn << ", ";
-                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, "value")) {
+                if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     "value")) {
                     return false;
                 }
                 fn << ") {";
@@ -1592,8 +1589,8 @@
 
             {  // T result = {0};
                 auto l = line(&buf);
-                if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, "result")) {
+                if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     "result")) {
                     return false;
                 }
                 l << "=";
@@ -1628,7 +1625,7 @@
     if (!builtin->ReturnType()->Is<sem::Void>()) {
         auto pre = line();
         if (!EmitTypeAndName(pre, builtin->ReturnType(), ast::AddressSpace::kNone,
-                             ast::Access::kUndefined, result)) {
+                             ast::Access::kInvalid, result)) {
             return false;
         }
         pre << " = ";
@@ -1691,8 +1688,8 @@
             {  // T result = 0;
                 auto pre = line();
                 auto* value_ty = builtin->Parameters()[1]->Type()->UnwrapRef();
-                if (!EmitTypeAndName(pre, value_ty, ast::AddressSpace::kNone,
-                                     ast::Access::kUndefined, result)) {
+                if (!EmitTypeAndName(pre, value_ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                     result)) {
                     return false;
                 }
                 pre << " = ";
@@ -1732,7 +1729,7 @@
             {  // T compare_value = <compare_value>;
                 auto pre = line();
                 if (!EmitTypeAndName(pre, TypeOf(compare_value)->UnwrapRef(),
-                                     ast::AddressSpace::kNone, ast::Access::kUndefined, compare)) {
+                                     ast::AddressSpace::kNone, ast::Access::kInvalid, compare)) {
                     return false;
                 }
                 pre << " = ";
@@ -1842,7 +1839,7 @@
             {
                 auto l = line(b);
                 if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone,
-                              ast::Access::kUndefined, "")) {
+                              ast::Access::kInvalid, "")) {
                     return false;
                 }
                 l << " result;";
@@ -1884,7 +1881,7 @@
             {
                 auto l = line(b);
                 if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone,
-                              ast::Access::kUndefined, "")) {
+                              ast::Access::kInvalid, "")) {
                     return false;
                 }
                 l << " result = {sig, int" << width << "(exp)};";
@@ -2721,7 +2718,7 @@
 
             auto const* type = v->Type();
             auto address_space = ast::AddressSpace::kNone;
-            auto access = ast::Access::kUndefined;
+            auto access = ast::Access::kInvalid;
 
             if (auto* ptr = type->As<sem::Pointer>()) {
                 type = ptr->StoreType();
@@ -3010,6 +3007,8 @@
         case ast::InterpolationType::kFlat:
             modifiers += "nointerpolation ";
             break;
+        case ast::InterpolationType::kInvalid:
+            break;
     }
     switch (sampling) {
         case ast::InterpolationSampling::kCentroid:
@@ -3019,7 +3018,7 @@
             modifiers += "sample ";
             break;
         case ast::InterpolationSampling::kCenter:
-        case ast::InterpolationSampling::kNone:
+        case ast::InterpolationSampling::kInvalid:
             break;
     }
     return modifiers;
@@ -3141,7 +3140,7 @@
                 return true;
             }
 
-            if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -3158,7 +3157,7 @@
             return true;
         },
         [&](const sem::Matrix* m) {
-            if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+            if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                 return false;
             }
 
@@ -3177,7 +3176,7 @@
         [&](const sem::Array* a) {
             if (constant->AllZero()) {
                 out << "(";
-                if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+                if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                     return false;
                 }
                 out << ")0";
@@ -3207,7 +3206,7 @@
         [&](const sem::Struct* s) {
             if (constant->AllZero()) {
                 out << "(";
-                if (!EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) {
+                if (!EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kInvalid, "")) {
                     return false;
                 }
                 out << ")0";
@@ -3328,12 +3327,12 @@
         [&](const sem::Struct*) {
             out << "(";
             TINT_DEFER(out << ")" << value);
-            return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "");
+            return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid, "");
         },
         [&](const sem::Array*) {
             out << "(";
             TINT_DEFER(out << ")" << value);
-            return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "");
+            return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid, "");
         },
         [&](Default) {
             diagnostics_.add_error(
@@ -4081,7 +4080,7 @@
 
     auto out = line();
     out << "const ";
-    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined,
+    if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kInvalid,
                          builder_.Symbols().NameFor(let->symbol))) {
         return false;
     }
@@ -4109,7 +4108,7 @@
         {
             auto decl = line(&b);
             if (!EmitTypeAndName(decl, builtin->ReturnType(), ast::AddressSpace::kNone,
-                                 ast::Access::kUndefined, fn_name)) {
+                                 ast::Access::kInvalid, fn_name)) {
                 return "";
             }
             {
@@ -4124,8 +4123,8 @@
                         decl << "inout ";
                         ty = ptr->StoreType();
                     }
-                    if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone,
-                                         ast::Access::kUndefined, param_name)) {
+                    if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, ast::Access::kInvalid,
+                                         param_name)) {
                         return "";
                     }
                     parameter_names.emplace_back(std::move(param_name));
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 9517ec8..5db1d8f 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -1947,7 +1947,7 @@
         case ast::InterpolationSampling::kSample:
             attr = "sample_";
             break;
-        case ast::InterpolationSampling::kNone:
+        case ast::InterpolationSampling::kInvalid:
             break;
     }
     switch (type) {
@@ -1960,6 +1960,8 @@
         case ast::InterpolationType::kFlat:
             attr += "flat";
             break;
+        case ast::InterpolationType::kInvalid:
+            break;
     }
     return attr;
 }
diff --git a/src/tint/writer/msl/generator_impl_cast_test.cc b/src/tint/writer/msl/generator_impl_cast_test.cc
index 4b9e3f2..74b3be6 100644
--- a/src/tint/writer/msl/generator_impl_cast_test.cc
+++ b/src/tint/writer/msl/generator_impl_cast_test.cc
@@ -51,7 +51,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitExpression(out, cast)) << gen.error();
-    EXPECT_EQ(out.str(), "0u");
+    EXPECT_EQ(out.str(), "2147483648u");
 }
 
 }  // namespace
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 5bd6407..57a363d 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -766,7 +766,7 @@
                     push_annot(spv::Op::OpDecorate,
                                {Operand(var_id), U32Operand(SpvDecorationNonWritable)});
                     break;
-                case ast::Access::kUndefined:
+                case ast::Access::kInvalid:
                 case ast::Access::kReadWrite:
                     break;
             }
@@ -3684,11 +3684,11 @@
     // references are not legal in WGSL, so only considering the top-level type is
     // fine.
     if (auto* ptr = type->As<sem::Pointer>()) {
-        type =
-            builder_.create<sem::Pointer>(ptr->StoreType(), ptr->AddressSpace(), ast::kReadWrite);
+        type = builder_.create<sem::Pointer>(ptr->StoreType(), ptr->AddressSpace(),
+                                             ast::Access::kReadWrite);
     } else if (auto* ref = type->As<sem::Reference>()) {
-        type =
-            builder_.create<sem::Pointer>(ref->StoreType(), ref->AddressSpace(), ast::kReadWrite);
+        type = builder_.create<sem::Pointer>(ref->StoreType(), ref->AddressSpace(),
+                                             ast::Access::kReadWrite);
     }
 
     return utils::GetOrCreate(type_to_id_, type, [&]() -> uint32_t {
@@ -4088,6 +4088,7 @@
             push_annot(spv::Op::OpDecorate, {Operand(id), U32Operand(SpvDecorationFlat)});
             break;
         case ast::InterpolationType::kPerspective:
+        case ast::InterpolationType::kInvalid:
             break;
     }
     switch (sampling) {
@@ -4099,7 +4100,7 @@
             push_annot(spv::Op::OpDecorate, {Operand(id), U32Operand(SpvDecorationSample)});
             break;
         case ast::InterpolationSampling::kCenter:
-        case ast::InterpolationSampling::kNone:
+        case ast::InterpolationSampling::kInvalid:
             break;
     }
 }
diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc
index 05f1a5a..cf43f23 100644
--- a/src/tint/writer/wgsl/generator_impl.cc
+++ b/src/tint/writer/wgsl/generator_impl.cc
@@ -433,7 +433,7 @@
             if (!EmitType(out, ptr->type)) {
                 return false;
             }
-            if (ptr->access != ast::Access::kUndefined) {
+            if (ptr->access != ast::Access::kInvalid) {
                 out << ", ";
                 if (!EmitAccess(out, ptr->access)) {
                     return false;
@@ -656,9 +656,9 @@
             out << "var";
             auto address_space = var->declared_address_space;
             auto ac = var->declared_access;
-            if (address_space != ast::AddressSpace::kNone || ac != ast::Access::kUndefined) {
+            if (address_space != ast::AddressSpace::kNone || ac != ast::Access::kInvalid) {
                 out << "<" << address_space;
-                if (ac != ast::Access::kUndefined) {
+                if (ac != ast::Access::kInvalid) {
                     out << ", ";
                     if (!EmitAccess(out, ac)) {
                         return false;
@@ -769,7 +769,7 @@
             },
             [&](const ast::InterpolateAttribute* interpolate) {
                 out << "interpolate(" << interpolate->type;
-                if (interpolate->sampling != ast::InterpolationSampling::kNone) {
+                if (interpolate->sampling != ast::InterpolationSampling::kInvalid) {
                     out << ", " << interpolate->sampling;
                 }
                 out << ")";