diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 2ba988c..be99389 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -543,8 +543,6 @@
     "transform/vertex_pulling.h",
     "transform/while_to_loop.cc",
     "transform/while_to_loop.h",
-    "transform/wrap_arrays_in_structs.cc",
-    "transform/wrap_arrays_in_structs.h",
     "transform/zero_init_workgroup_memory.cc",
     "transform/zero_init_workgroup_memory.h",
     "utils/bitcast.h",
@@ -1199,7 +1197,6 @@
       "transform/vectorize_scalar_matrix_constructors_test.cc",
       "transform/vertex_pulling_test.cc",
       "transform/while_to_loop_test.cc",
-      "transform/wrap_arrays_in_structs_test.cc",
       "transform/zero_init_workgroup_memory_test.cc",
     ]
   }
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 3734367..10d81d6 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -466,8 +466,6 @@
   transform/vertex_pulling.h
   transform/while_to_loop.cc
   transform/while_to_loop.h
-  transform/wrap_arrays_in_structs.cc
-  transform/wrap_arrays_in_structs.h
   transform/zero_init_workgroup_memory.cc
   transform/zero_init_workgroup_memory.h
   utils/bitcast.h
@@ -1121,7 +1119,6 @@
       transform/vectorize_scalar_matrix_constructors_test.cc
       transform/vertex_pulling_test.cc
       transform/while_to_loop_test.cc
-      transform/wrap_arrays_in_structs_test.cc
       transform/zero_init_workgroup_memory_test.cc
       transform/utils/get_insertion_point_test.cc
       transform/utils/hoist_to_decl_before_test.cc
diff --git a/src/tint/transform/wrap_arrays_in_structs.cc b/src/tint/transform/wrap_arrays_in_structs.cc
deleted file mode 100644
index eb133d7..0000000
--- a/src/tint/transform/wrap_arrays_in_structs.cc
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright 2021 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/transform/wrap_arrays_in_structs.h"
-
-#include <utility>
-
-#include "src/tint/program_builder.h"
-#include "src/tint/sem/array.h"
-#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
-#include "src/tint/sem/type_constructor.h"
-#include "src/tint/utils/map.h"
-#include "src/tint/utils/transform.h"
-
-TINT_INSTANTIATE_TYPEINFO(tint::transform::WrapArraysInStructs);
-
-namespace tint::transform {
-
-WrapArraysInStructs::WrappedArrayInfo::WrappedArrayInfo() = default;
-WrapArraysInStructs::WrappedArrayInfo::WrappedArrayInfo(const WrappedArrayInfo&) = default;
-WrapArraysInStructs::WrappedArrayInfo::~WrappedArrayInfo() = default;
-
-WrapArraysInStructs::WrapArraysInStructs() = default;
-
-WrapArraysInStructs::~WrapArraysInStructs() = default;
-
-bool WrapArraysInStructs::ShouldRun(const Program* program, const DataMap&) const {
-    for (auto* node : program->ASTNodes().Objects()) {
-        if (program->Sem().Get<sem::Array>(node->As<ast::Type>())) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void WrapArraysInStructs::Run(CloneContext& ctx, const DataMap&, DataMap&) const {
-    auto& sem = ctx.src->Sem();
-
-    std::unordered_map<const sem::Array*, WrappedArrayInfo> wrapped_arrays;
-    auto wrapper = [&](const sem::Array* array) { return WrapArray(ctx, wrapped_arrays, array); };
-    auto wrapper_typename = [&](const sem::Array* arr) -> ast::TypeName* {
-        auto info = wrapper(arr);
-        return info ? ctx.dst->create<ast::TypeName>(info.wrapper_name) : nullptr;
-    };
-
-    // Replace all array types with their corresponding wrapper
-    ctx.ReplaceAll([&](const ast::Type* ast_type) -> const ast::Type* {
-        auto* type = ctx.src->TypeOf(ast_type);
-        if (auto* array = type->UnwrapRef()->As<sem::Array>()) {
-            return wrapper_typename(array);
-        }
-        return nullptr;
-    });
-
-    // Fix up index accessors so `a[1]` becomes `a.arr[1]`
-    ctx.ReplaceAll(
-        [&](const ast::IndexAccessorExpression* accessor) -> const ast::IndexAccessorExpression* {
-            if (auto* array =
-                    ::tint::As<sem::Array>(sem.Get(accessor->object)->Type()->UnwrapRef())) {
-                if (wrapper(array)) {
-                    // Array is wrapped in a structure. Emit a member accessor to get
-                    // to the actual array.
-                    auto* arr = ctx.Clone(accessor->object);
-                    auto* idx = ctx.Clone(accessor->index);
-                    auto* unwrapped = ctx.dst->MemberAccessor(arr, "arr");
-                    return ctx.dst->IndexAccessor(accessor->source, unwrapped, idx);
-                }
-            }
-            return nullptr;
-        });
-
-    // Fix up array constructors so `A(1,2)` becomes `tint_array_wrapper(A(1,2))`
-    ctx.ReplaceAll([&](const ast::CallExpression* expr) -> const ast::Expression* {
-        if (auto* call = sem.Get(expr)->UnwrapMaterialize()->As<sem::Call>()) {
-            if (auto* ctor = call->Target()->As<sem::TypeConstructor>()) {
-                if (auto* array = ctor->ReturnType()->As<sem::Array>()) {
-                    if (auto w = wrapper(array)) {
-                        // Wrap the array type constructor with another constructor for
-                        // the wrapper
-                        auto* wrapped_array_ty = ctx.dst->ty.type_name(w.wrapper_name);
-                        auto* array_ty = w.array_type(ctx);
-                        auto args = utils::Transform(call->Arguments(),
-                                                     [&](const tint::sem::Expression* s) {
-                                                         return ctx.Clone(s->Declaration());
-                                                     });
-                        auto* arr_ctor = ctx.dst->Construct(array_ty, args);
-                        return ctx.dst->Construct(wrapped_array_ty, arr_ctor);
-                    }
-                }
-            }
-        }
-        return nullptr;
-    });
-
-    ctx.Clone();
-}
-
-WrapArraysInStructs::WrappedArrayInfo WrapArraysInStructs::WrapArray(
-    CloneContext& ctx,
-    std::unordered_map<const sem::Array*, WrappedArrayInfo>& wrapped_arrays,
-    const sem::Array* array) const {
-    if (array->IsRuntimeSized()) {
-        return {};  // We don't want to wrap runtime sized arrays
-    }
-
-    return utils::GetOrCreate(wrapped_arrays, array, [&] {
-        WrappedArrayInfo info;
-
-        // Generate a unique name for the array wrapper
-        info.wrapper_name = ctx.dst->Symbols().New("tint_array_wrapper");
-
-        // Examine the element type. Is it also an array?
-        std::function<const ast::Type*(CloneContext&)> el_type;
-        if (auto* el_array = array->ElemType()->As<sem::Array>()) {
-            // Array of array - call WrapArray() on the element type
-            if (auto el = WrapArray(ctx, wrapped_arrays, el_array)) {
-                el_type = [=](CloneContext& c) {
-                    return c.dst->create<ast::TypeName>(el.wrapper_name);
-                };
-            }
-        }
-
-        // If the element wasn't an array, just create the typical AST type for it
-        if (!el_type) {
-            el_type = [=](CloneContext& c) { return CreateASTTypeFor(c, array->ElemType()); };
-        }
-
-        // Construct the single structure field type
-        info.array_type = [=](CloneContext& c) {
-            ast::AttributeList attrs;
-            if (!array->IsStrideImplicit()) {
-                attrs.emplace_back(c.dst->create<ast::StrideAttribute>(array->Stride()));
-            }
-            return c.dst->ty.array(el_type(c), u32(array->Count()), std::move(attrs));
-        };
-
-        // Structure() will create and append the ast::Struct to the
-        // global declarations of `ctx.dst`. As we haven't finished building the
-        // current module-scope statement or function, this will be placed
-        // immediately before the usage.
-        ctx.dst->Structure(info.wrapper_name, {ctx.dst->Member("arr", info.array_type(ctx))});
-        return info;
-    });
-}
-
-}  // namespace tint::transform
diff --git a/src/tint/transform/wrap_arrays_in_structs.h b/src/tint/transform/wrap_arrays_in_structs.h
deleted file mode 100644
index 4653c6b..0000000
--- a/src/tint/transform/wrap_arrays_in_structs.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2021 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_TINT_TRANSFORM_WRAP_ARRAYS_IN_STRUCTS_H_
-#define SRC_TINT_TRANSFORM_WRAP_ARRAYS_IN_STRUCTS_H_
-
-#include <string>
-#include <unordered_map>
-
-#include "src/tint/transform/transform.h"
-
-// Forward declarations
-namespace tint::ast {
-class Type;
-}  // namespace tint::ast
-
-namespace tint::transform {
-
-/// WrapArraysInStructs is a transform that replaces all array types with a
-/// structure holding a single field of that array type.
-/// Array index expressions and constructors are also adjusted to deal with this
-/// wrapping.
-/// This transform helps with backends that cannot directly return arrays or use
-/// them as parameters.
-class WrapArraysInStructs : public Castable<WrapArraysInStructs, Transform> {
-  public:
-    /// Constructor
-    WrapArraysInStructs();
-
-    /// Destructor
-    ~WrapArraysInStructs() 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;
-
-  private:
-    struct WrappedArrayInfo {
-        WrappedArrayInfo();
-        WrappedArrayInfo(const WrappedArrayInfo&);
-        ~WrappedArrayInfo();
-
-        Symbol wrapper_name;
-        std::function<const ast::Type*(CloneContext&)> array_type;
-
-        operator bool() { return wrapper_name.IsValid(); }
-    };
-
-    /// WrapArray wraps the fixed-size array type in a new structure (if it hasn't
-    /// already been wrapped). WrapArray will recursively wrap arrays-of-arrays.
-    /// The new structure will be added to module-scope type declarations of
-    /// `ctx.dst`.
-    /// @param ctx the CloneContext
-    /// @param wrapped_arrays a map of src array type to the wrapped structure
-    /// name
-    /// @param array the array type
-    /// @return the name of the structure that wraps the array, or an invalid
-    /// Symbol if this array should not be wrapped
-    WrappedArrayInfo WrapArray(
-        CloneContext& ctx,
-        std::unordered_map<const sem::Array*, WrappedArrayInfo>& wrapped_arrays,
-        const sem::Array* array) const;
-};
-
-}  // namespace tint::transform
-
-#endif  // SRC_TINT_TRANSFORM_WRAP_ARRAYS_IN_STRUCTS_H_
diff --git a/src/tint/transform/wrap_arrays_in_structs_test.cc b/src/tint/transform/wrap_arrays_in_structs_test.cc
deleted file mode 100644
index 7a7a6b3..0000000
--- a/src/tint/transform/wrap_arrays_in_structs_test.cc
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright 2021 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/transform/wrap_arrays_in_structs.h"
-
-#include <memory>
-#include <utility>
-
-#include "src/tint/transform/test_helper.h"
-
-namespace tint::transform {
-namespace {
-
-using WrapArraysInStructsTest = TransformTest;
-
-TEST_F(WrapArraysInStructsTest, ShouldRunEmptyModule) {
-    auto* src = R"()";
-
-    EXPECT_FALSE(ShouldRun<WrapArraysInStructs>(src));
-}
-
-TEST_F(WrapArraysInStructsTest, ShouldRunHasArray) {
-    auto* src = R"(
-var<private> arr : array<i32, 4>;
-)";
-
-    EXPECT_TRUE(ShouldRun<WrapArraysInStructs>(src));
-}
-
-TEST_F(WrapArraysInStructsTest, EmptyModule) {
-    auto* src = R"()";
-    auto* expect = src;
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAsGlobal) {
-    auto* src = R"(
-var<private> arr : array<i32, 4>;
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-var<private> arr : tint_array_wrapper;
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAsFunctionVar) {
-    auto* src = R"(
-fn f() {
-  var arr : array<i32, 4>;
-  let x = arr[3];
-}
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-fn f() {
-  var arr : tint_array_wrapper;
-  let x = arr.arr[3];
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAsParam) {
-    auto* src = R"(
-fn f(a : array<i32, 4>) -> i32 {
-  return a[2];
-}
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-fn f(a : tint_array_wrapper) -> i32 {
-  return a.arr[2];
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAsReturn) {
-    auto* src = R"(
-fn f() -> array<i32, 4> {
-  return array<i32, 4>(1, 2, 3, 4);
-}
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-fn f() -> tint_array_wrapper {
-  return tint_array_wrapper(array<i32, 4u>(1, 2, 3, 4));
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAlias) {
-    auto* src = R"(
-type Inner = array<i32, 2>;
-type Array = array<Inner, 2>;
-
-fn f() {
-  var arr : Array;
-  arr = Array();
-  arr = Array(Inner(1, 2), Inner(3, 4));
-  let vals : Array = Array(Inner(1, 2), Inner(3, 4));
-  arr = vals;
-  let x = arr[3];
-}
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 2u>,
-}
-
-type Inner = tint_array_wrapper;
-
-struct tint_array_wrapper_1 {
-  arr : array<tint_array_wrapper, 2u>,
-}
-
-type Array = tint_array_wrapper_1;
-
-fn f() {
-  var arr : tint_array_wrapper_1;
-  arr = tint_array_wrapper_1(array<tint_array_wrapper, 2u>());
-  arr = tint_array_wrapper_1(array<tint_array_wrapper, 2u>(tint_array_wrapper(array<i32, 2u>(1, 2)), tint_array_wrapper(array<i32, 2u>(3, 4))));
-  let vals : tint_array_wrapper_1 = tint_array_wrapper_1(array<tint_array_wrapper, 2u>(tint_array_wrapper(array<i32, 2u>(1, 2)), tint_array_wrapper(array<i32, 2u>(3, 4))));
-  arr = vals;
-  let x = arr.arr[3];
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArrayAlias_OutOfOrder) {
-    auto* src = R"(
-fn f() {
-  var arr : Array;
-  arr = Array();
-  arr = Array(Inner(1, 2), Inner(3, 4));
-  let vals : Array = Array(Inner(1, 2), Inner(3, 4));
-  arr = vals;
-  let x = arr[3];
-}
-
-type Array = array<Inner, 2>;
-type Inner = array<i32, 2>;
-)";
-    auto* expect = R"(
-struct tint_array_wrapper_1 {
-  arr : array<i32, 2u>,
-}
-
-struct tint_array_wrapper {
-  arr : array<tint_array_wrapper_1, 2u>,
-}
-
-fn f() {
-  var arr : tint_array_wrapper;
-  arr = tint_array_wrapper(array<tint_array_wrapper_1, 2u>());
-  arr = tint_array_wrapper(array<tint_array_wrapper_1, 2u>(tint_array_wrapper_1(array<i32, 2u>(1, 2)), tint_array_wrapper_1(array<i32, 2u>(3, 4))));
-  let vals : tint_array_wrapper = tint_array_wrapper(array<tint_array_wrapper_1, 2u>(tint_array_wrapper_1(array<i32, 2u>(1, 2)), tint_array_wrapper_1(array<i32, 2u>(3, 4))));
-  arr = vals;
-  let x = arr.arr[3];
-}
-
-type Array = tint_array_wrapper;
-
-type Inner = tint_array_wrapper_1;
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArraysInStruct) {
-    auto* src = R"(
-struct S {
-  a : array<i32, 4>,
-  b : array<i32, 8>,
-  c : array<i32, 4>,
-};
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-struct tint_array_wrapper_1 {
-  arr : array<i32, 8u>,
-}
-
-struct S {
-  a : tint_array_wrapper,
-  b : tint_array_wrapper_1,
-  c : tint_array_wrapper,
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, ArraysOfArraysInStruct) {
-    auto* src = R"(
-struct S {
-  a : array<i32, 4>,
-  b : array<array<i32, 4>, 4>,
-  c : array<array<array<i32, 4>, 4>, 4>,
-};
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-struct tint_array_wrapper_1 {
-  arr : array<tint_array_wrapper, 4u>,
-}
-
-struct tint_array_wrapper_2 {
-  arr : array<tint_array_wrapper_1, 4u>,
-}
-
-struct S {
-  a : tint_array_wrapper,
-  b : tint_array_wrapper_1,
-  c : tint_array_wrapper_2,
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, AccessArraysOfArraysInStruct) {
-    auto* src = R"(
-struct S {
-  a : array<i32, 4>,
-  b : array<array<i32, 4>, 4>,
-  c : array<array<array<i32, 4>, 4>, 4>,
-};
-
-fn f(s : S) -> i32 {
-  return s.a[2] + s.b[1][2] + s.c[3][1][2];
-}
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 4u>,
-}
-
-struct tint_array_wrapper_1 {
-  arr : array<tint_array_wrapper, 4u>,
-}
-
-struct tint_array_wrapper_2 {
-  arr : array<tint_array_wrapper_1, 4u>,
-}
-
-struct S {
-  a : tint_array_wrapper,
-  b : tint_array_wrapper_1,
-  c : tint_array_wrapper_2,
-}
-
-fn f(s : S) -> i32 {
-  return ((s.a.arr[2] + s.b.arr[1].arr[2]) + s.c.arr[3].arr[1].arr[2]);
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, DeclarationOrder) {
-    auto* src = R"(
-type T0 = i32;
-
-type T1 = array<i32, 1>;
-
-type T2 = i32;
-
-fn f1(a : array<i32, 2>) {
-}
-
-type T3 = i32;
-
-fn f2() {
-  var v : array<i32, 3>;
-}
-)";
-    auto* expect = R"(
-type T0 = i32;
-
-struct tint_array_wrapper {
-  arr : array<i32, 1u>,
-}
-
-type T1 = tint_array_wrapper;
-
-type T2 = i32;
-
-struct tint_array_wrapper_1 {
-  arr : array<i32, 2u>,
-}
-
-fn f1(a : tint_array_wrapper_1) {
-}
-
-type T3 = i32;
-
-struct tint_array_wrapper_2 {
-  arr : array<i32, 3u>,
-}
-
-fn f2() {
-  var v : tint_array_wrapper_2;
-}
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-TEST_F(WrapArraysInStructsTest, DeclarationOrder_OutOfOrder) {
-    auto* src = R"(
-fn f2() {
-  var v : array<i32, 3>;
-}
-
-type T3 = i32;
-
-fn f1(a : array<i32, 2>) {
-}
-
-type T2 = i32;
-
-type T1 = array<i32, 1>;
-
-type T0 = i32;
-)";
-    auto* expect = R"(
-struct tint_array_wrapper {
-  arr : array<i32, 3u>,
-}
-
-fn f2() {
-  var v : tint_array_wrapper;
-}
-
-type T3 = i32;
-
-struct tint_array_wrapper_1 {
-  arr : array<i32, 2u>,
-}
-
-fn f1(a : tint_array_wrapper_1) {
-}
-
-type T2 = i32;
-
-struct tint_array_wrapper_2 {
-  arr : array<i32, 1u>,
-}
-
-type T1 = tint_array_wrapper_2;
-
-type T0 = i32;
-)";
-
-    auto got = Run<WrapArraysInStructs>(src);
-
-    EXPECT_EQ(expect, str(got));
-}
-
-}  // namespace
-}  // namespace tint::transform
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 971d16d..7df2ffb 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -71,7 +71,6 @@
 #include "src/tint/transform/unshadow.h"
 #include "src/tint/transform/unwind_discard_functions.h"
 #include "src/tint/transform/vectorize_scalar_matrix_constructors.h"
-#include "src/tint/transform/wrap_arrays_in_structs.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
 #include "src/tint/utils/defer.h"
 #include "src/tint/utils/map.h"
@@ -208,7 +207,6 @@
     manager.Add<transform::PromoteInitializersToConstVar>();
 
     manager.Add<transform::VectorizeScalarMatrixConstructors>();
-    manager.Add<transform::WrapArraysInStructs>();
     manager.Add<transform::RemovePhonies>();
     manager.Add<transform::SimplifyPointers>();
     // ArrayLengthFromUniform must come after SimplifyPointers, as
@@ -731,13 +729,33 @@
                                         const sem::TypeConstructor* ctor) {
     auto* type = ctor->ReturnType();
 
-    if (type->IsAnyOf<sem::Array, sem::Struct>()) {
-        out << "{";
-    } else {
-        if (!EmitType(out, type, "")) {
-            return false;
-        }
-        out << "(";
+    const char* terminator = ")";
+    TINT_DEFER(out << terminator);
+
+    bool ok = Switch(
+        type,
+        [&](const sem::Array*) {
+            if (!EmitType(out, type, "")) {
+                return false;
+            }
+            out << "{";
+            terminator = "}";
+            return true;
+        },
+        [&](const sem::Struct*) {
+            out << "{";
+            terminator = "}";
+            return true;
+        },
+        [&](Default) {
+            if (!EmitType(out, type, "")) {
+                return false;
+            }
+            out << "(";
+            return true;
+        });
+    if (!ok) {
+        return false;
     }
 
     int i = 0;
@@ -760,11 +778,6 @@
         i++;
     }
 
-    if (type->IsAnyOf<sem::Array, sem::Struct>()) {
-        out << "}";
-    } else {
-        out << ")";
-    }
     return true;
 }
 
@@ -1561,10 +1574,9 @@
             ScopedParen sp(out);
             return EmitZeroValue(out, mat->type());
         },
-        [&](const sem::Array* arr) {
-            out << "{";
-            TINT_DEFER(out << "}");
-            return EmitZeroValue(out, arr->ElemType());
+        [&](const sem::Array*) {
+            out << "{}";
+            return true;
         },
         [&](const sem::Struct*) {
             out << "{}";
@@ -1772,8 +1784,8 @@
             if (!EmitType(out, type, param_name)) {
                 return false;
             }
-            // Parameter name is output as part of the type for arrays and pointers.
-            if (!type->Is<sem::Array>() && !type->Is<sem::Pointer>()) {
+            // Parameter name is output as part of the type for pointers.
+            if (!type->Is<sem::Pointer>()) {
                 out << " " << program_->Symbols().NameFor(v->symbol);
             }
         }
@@ -1896,8 +1908,8 @@
             if (!EmitType(out, type, param_name)) {
                 return false;
             }
-            // Parameter name is output as part of the type for arrays and pointers.
-            if (!type->Is<sem::Array>() && !type->Is<sem::Pointer>()) {
+            // Parameter name is output as part of the type for pointers.
+            if (!type->Is<sem::Pointer>()) {
                 out << " " << param_name;
             }
 
@@ -2412,29 +2424,12 @@
                 << "unhandled atomic type " << atomic->Type()->FriendlyName(builder_.Symbols());
             return false;
         },
-        [&](const sem::Array* ary) {
-            const sem::Type* base_type = ary;
-            std::vector<uint32_t> sizes;
-            while (auto* arr = base_type->As<sem::Array>()) {
-                if (arr->IsRuntimeSized()) {
-                    sizes.push_back(1);
-                } else {
-                    sizes.push_back(arr->Count());
-                }
-                base_type = arr->ElemType();
-            }
-            if (!EmitType(out, base_type, "")) {
+        [&](const sem::Array* arr) {
+            out << ArrayType() << "<";
+            if (!EmitType(out, arr->ElemType(), "")) {
                 return false;
             }
-            if (!name.empty()) {
-                out << " " << name;
-                if (name_printed) {
-                    *name_printed = true;
-                }
-            }
-            for (uint32_t size : sizes) {
-                out << "[" << size << "]";
-            }
+            out << ", " << (arr->IsRuntimeSized() ? 1u : arr->Count()) << ">";
             return true;
         },
         [&](const sem::Bool*) {
@@ -2469,22 +2464,12 @@
                 return false;
             }
             out << " ";
-            if (ptr->StoreType()->Is<sem::Array>()) {
-                std::string inner = "(*" + name + ")";
-                if (!EmitType(out, ptr->StoreType(), inner)) {
-                    return false;
-                }
-                if (name_printed) {
-                    *name_printed = true;
-                }
-            } else {
-                if (!EmitType(out, ptr->StoreType(), "")) {
-                    return false;
-                }
-                out << "* " << name;
-                if (name_printed) {
-                    *name_printed = true;
-                }
+            if (!EmitType(out, ptr->StoreType(), "")) {
+                return false;
+            }
+            out << "* " << name;
+            if (name_printed) {
+                *name_printed = true;
             }
             return true;
         },
@@ -2700,7 +2685,7 @@
 
         auto out = line(b);
         add_byte_offset_comment(out, msl_offset);
-        out << "int8_t " << name << "[" << size << "];";
+        out << ArrayType() << "<int8_t, " << size << "> " << name << ";";
     };
 
     b->IncrementIndent();
@@ -2738,11 +2723,7 @@
 
         auto* ty = mem->Type();
 
-        // Array member name will be output with the type
-        if (!ty->Is<sem::Array>()) {
-            out << " " << mem_name;
-        }
-
+        out << " " << mem_name;
         // Emit attributes
         if (auto* decl = mem->Declaration()) {
             for (auto* attr : decl->attributes) {
@@ -2945,8 +2926,8 @@
     if (!EmitType(out, type, name)) {
         return false;
     }
-    // Variable name is output as part of the type for arrays and pointers.
-    if (!type->Is<sem::Array>() && !type->Is<sem::Pointer>()) {
+    // Variable name is output as part of the type for pointers.
+    if (!type->Is<sem::Pointer>()) {
         out << " " << name;
     }
 
@@ -2995,8 +2976,8 @@
         return false;
     }
 
-    // Variable name is output as part of the type for arrays and pointers.
-    if (!type->Is<sem::Array>() && !type->Is<sem::Pointer>()) {
+    // Variable name is output as part of the type for pointers.
+    if (!type->Is<sem::Pointer>()) {
         out << " " << name;
     }
 
@@ -3018,9 +2999,7 @@
     if (!EmitType(out, type, program_->Symbols().NameFor(let->symbol))) {
         return false;
     }
-    if (!type->Is<sem::Array>()) {
-        out << " " << program_->Symbols().NameFor(let->symbol);
-    }
+    out << " " << program_->Symbols().NameFor(let->symbol);
 
     if (let->constructor != nullptr) {
         out << " = ";
@@ -3042,9 +3021,7 @@
     if (!EmitType(out, type, program_->Symbols().NameFor(override->symbol))) {
         return false;
     }
-    if (!type->Is<sem::Array>()) {
-        out << " " << program_->Symbols().NameFor(override->symbol);
-    }
+    out << " " << program_->Symbols().NameFor(override->symbol);
 
     out << " [[function_constant(" << global->ConstantId() << ")]];";
 
@@ -3117,8 +3094,8 @@
 
         [&](const sem::Array* arr) {
             if (!arr->IsStrideImplicit()) {
-                TINT_ICE(Writer, diagnostics_) << "arrays with explicit strides not "
-                                                  "exist past the SPIR-V reader";
+                TINT_ICE(Writer, diagnostics_)
+                    << "arrays with explicit strides should not exist past the SPIR-V reader";
                 return SizeAndAlign{};
             }
             auto num_els = std::max<uint32_t>(arr->Count(), 1);
@@ -3205,4 +3182,25 @@
     return true;
 }
 
+const std::string& GeneratorImpl::ArrayType() {
+    if (array_template_name_.empty()) {
+        array_template_name_ = UniqueIdentifier("tint_array");
+        auto* buf = &helpers_;
+        line(buf) << "template<typename T, size_t N>";
+        line(buf) << "struct " << array_template_name_ << " {";
+        line(buf) << "    const constant T& operator[](size_t i) const constant"
+                  << " { return elements[i]; }";
+        for (auto* space : {"device", "thread", "threadgroup"}) {
+            line(buf) << "    " << space << " T& operator[](size_t i) " << space
+                      << " { return elements[i]; }";
+            line(buf) << "    const " << space << " T& operator[](size_t i) const " << space
+                      << " { return elements[i]; }";
+        }
+        line(buf) << "    T elements[N];";
+        line(buf) << "};";
+        line(buf);
+    }
+    return array_template_name_;
+}
+
 }  // namespace tint::writer::msl
diff --git a/src/tint/writer/msl/generator_impl.h b/src/tint/writer/msl/generator_impl.h
index d80d501..f0d4e8c 100644
--- a/src/tint/writer/msl/generator_impl.h
+++ b/src/tint/writer/msl/generator_impl.h
@@ -425,6 +425,10 @@
                            const sem::Builtin* builtin,
                            F&& build);
 
+    /// @returns the name of the templated tint_array helper type, generating it if this is the
+    /// first call.
+    const std::string& ArrayType();
+
     TextBuffer helpers_;  // Helper functions emitted at the top of the output
 
     /// @returns the MSL packed type size and alignment in bytes for the given
@@ -439,13 +443,17 @@
         utils::UnorderedKeyWrapper<std::tuple<ast::StorageClass, const sem::Struct*>>;
     std::unordered_map<ACEWKeyType, std::string> atomicCompareExchangeWeak_;
 
-    /// Unique name of the 'TINT_INVARIANT' preprocessor define. Non-empty only if
-    /// an invariant attribute has been generated.
+    /// Unique name of the 'TINT_INVARIANT' preprocessor define.
+    /// Non-empty only if an invariant attribute has been generated.
     std::string invariant_define_name_;
 
     /// True if matrix-packed_vector operator overloads have been generated.
     bool matrix_packed_vector_overloads_ = false;
 
+    /// Unique name of the tint_array<T, N> template.
+    /// Non-empty only if the template has been generated.
+    std::string array_template_name_;
+
     /// A map from entry point name to a list of dynamic workgroup allocations.
     /// Each entry in the vector is the size of the workgroup allocation that
     /// should be created for that index.
diff --git a/src/tint/writer/msl/generator_impl_function_test.cc b/src/tint/writer/msl/generator_impl_function_test.cc
index f7d2779..4ef8b12 100644
--- a/src/tint/writer/msl/generator_impl_function_test.cc
+++ b/src/tint/writer/msl/generator_impl_function_test.cc
@@ -591,11 +591,20 @@
     EXPECT_EQ(gen.result(), R"(  #include <metal_stdlib>
 
   using namespace metal;
-  struct tint_array_wrapper {
-    float arr[5];
-  };
 
-  void my_func(tint_array_wrapper a) {
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+  void my_func(tint_array<float, 5> a) {
     return;
   }
 
@@ -616,12 +625,21 @@
     EXPECT_EQ(gen.result(), R"(  #include <metal_stdlib>
 
   using namespace metal;
-  struct tint_array_wrapper {
-    float arr[5];
-  };
 
-  tint_array_wrapper my_func() {
-    tint_array_wrapper const tint_symbol = {.arr={}};
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+  tint_array<float, 5> my_func() {
+    tint_array<float, 5> const tint_symbol = tint_array<float, 5>{};
     return tint_symbol;
   }
 
diff --git a/src/tint/writer/msl/generator_impl_module_constant_test.cc b/src/tint/writer/msl/generator_impl_module_constant_test.cc
index f23e51a..12d1cf0 100644
--- a/src/tint/writer/msl/generator_impl_module_constant_test.cc
+++ b/src/tint/writer/msl/generator_impl_module_constant_test.cc
@@ -28,7 +28,7 @@
     GeneratorImpl& gen = Build();
 
     ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
-    EXPECT_EQ(gen.result(), "constant float pos[3] = {1.0f, 2.0f, 3.0f};\n");
+    EXPECT_EQ(gen.result(), "constant tint_array<float, 3> pos = tint_array<float, 3>{1.0f, 2.0f, 3.0f};\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
diff --git a/src/tint/writer/msl/generator_impl_sanitizer_test.cc b/src/tint/writer/msl/generator_impl_sanitizer_test.cc
index 475025c..9b9f30b 100644
--- a/src/tint/writer/msl/generator_impl_sanitizer_test.cc
+++ b/src/tint/writer/msl/generator_impl_sanitizer_test.cc
@@ -50,12 +50,25 @@
     auto* expect = R"(#include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct my_struct {
-  float a[1];
+  tint_array<float, 1> a;
 };
 
 fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(30)]]) {
@@ -95,13 +108,26 @@
     auto* expect = R"(#include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct my_struct {
   float z;
-  float a[1];
+  tint_array<float, 1> a;
 };
 
 fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(30)]]) {
@@ -143,12 +169,25 @@
     auto* expect = R"(#include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct my_struct {
-  float a[1];
+  tint_array<float, 1> a;
 };
 
 fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(30)]]) {
@@ -196,12 +235,25 @@
     auto* expect = R"(#include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol {
-  /* 0x0000 */ uint4 buffer_size[2];
+  /* 0x0000 */ tint_array<uint4, 2> buffer_size;
 };
 
 struct my_struct {
-  float a[1];
+  tint_array<float, 1> a;
 };
 
 fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(29)]]) {
diff --git a/src/tint/writer/msl/generator_impl_test.cc b/src/tint/writer/msl/generator_impl_test.cc
index 183fef5..914b693 100644
--- a/src/tint/writer/msl/generator_impl_test.cc
+++ b/src/tint/writer/msl/generator_impl_test.cc
@@ -188,25 +188,34 @@
     EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float2x2 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct tint_symbol_3 {
-  tint_array_wrapper m;
+  tint_array<float2x2, 4> m;
 };
 
-void comp_main_inner(uint local_invocation_index, threadgroup tint_array_wrapper* const tint_symbol) {
+void comp_main_inner(uint local_invocation_index, threadgroup tint_array<float2x2, 4>* const tint_symbol) {
   for(uint idx = local_invocation_index; (idx < 4u); idx = (idx + 1u)) {
     uint const i = idx;
-    (*(tint_symbol)).arr[i] = float2x2(float2(0.0f), float2(0.0f));
+    (*(tint_symbol))[i] = float2x2(float2(0.0f), float2(0.0f));
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
-  tint_array_wrapper const x = *(tint_symbol);
+  tint_array<float2x2, 4> const x = *(tint_symbol);
 }
 
 kernel void comp_main(threadgroup tint_symbol_3* tint_symbol_2 [[threadgroup(0)]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
-  threadgroup tint_array_wrapper* const tint_symbol_1 = &((*(tint_symbol_2)).m);
+  threadgroup tint_array<float2x2, 4>* const tint_symbol_1 = &((*(tint_symbol_2)).m);
   comp_main_inner(local_invocation_index, tint_symbol_1);
   return;
 }
diff --git a/src/tint/writer/msl/generator_impl_type_test.cc b/src/tint/writer/msl/generator_impl_type_test.cc
index 257468b..b8ab89d 100644
--- a/src/tint/writer/msl/generator_impl_type_test.cc
+++ b/src/tint/writer/msl/generator_impl_type_test.cc
@@ -31,6 +31,20 @@
 namespace tint::writer::msl {
 namespace {
 
+void FormatMSLField(std::stringstream& out,
+                    const char* addr,
+                    const char* type,
+                    size_t array_count,
+                    const char* name) {
+    out << "  /* " << std::string(addr) << " */ ";
+    if (array_count == 0) {
+        out << type << " ";
+    } else {
+        out << "tint_array<" << type << ", " << std::to_string(array_count) << "> ";
+    }
+    out << name << ";\n";
+}
+
 #define CHECK_TYPE_SIZE_AND_ALIGN(TYPE, SIZE, ALIGN)      \
     static_assert(sizeof(TYPE) == SIZE, "Bad type size"); \
     static_assert(alignof(TYPE) == ALIGN, "Bad type alignment")
@@ -69,7 +83,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), "ary")) << gen.error();
-    EXPECT_EQ(out.str(), "bool ary[4]");
+    EXPECT_EQ(out.str(), "tint_array<bool, 4>");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) {
@@ -81,7 +95,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(b), "ary")) << gen.error();
-    EXPECT_EQ(out.str(), "bool ary[5][4]");
+    EXPECT_EQ(out.str(), "tint_array<tint_array<bool, 4>, 5>");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) {
@@ -94,7 +108,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(c), "ary")) << gen.error();
-    EXPECT_EQ(out.str(), "bool ary[6][5][4]");
+    EXPECT_EQ(out.str(), "tint_array<tint_array<tint_array<bool, 4>, 5>, 6>");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) {
@@ -105,7 +119,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), "")) << gen.error();
-    EXPECT_EQ(out.str(), "bool[4]");
+    EXPECT_EQ(out.str(), "tint_array<bool, 4>");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) {
@@ -116,7 +130,7 @@
 
     std::stringstream out;
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), "ary")) << gen.error();
-    EXPECT_EQ(out.str(), "bool ary[1]");
+    EXPECT_EQ(out.str(), "tint_array<bool, 1>");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Bool) {
@@ -245,54 +259,58 @@
     auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
 
-    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, NAME, SUFFIX)
+    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
-#define ALL_FIELDS()                               \
-    FIELD(0x0000, int, a, /*NO SUFFIX*/)           \
-    FIELD(0x0004, int8_t, tint_pad, [124])         \
-    FIELD(0x0080, float, b, /*NO SUFFIX*/)         \
-    FIELD(0x0084, int8_t, tint_pad_1, [124])       \
-    FIELD(0x0100, float2, c, /*NO SUFFIX*/)        \
-    FIELD(0x0108, uint, d, /*NO SUFFIX*/)          \
-    FIELD(0x010c, int8_t, tint_pad_2, [4])         \
-    FIELD(0x0110, packed_float3, e, /*NO SUFFIX*/) \
-    FIELD(0x011c, uint, f, /*NO SUFFIX*/)          \
-    FIELD(0x0120, float4, g, /*NO SUFFIX*/)        \
-    FIELD(0x0130, uint, h, /*NO SUFFIX*/)          \
-    FIELD(0x0134, int8_t, tint_pad_3, [4])         \
-    FIELD(0x0138, float2x2, i, /*NO SUFFIX*/)      \
-    FIELD(0x0148, uint, j, /*NO SUFFIX*/)          \
-    FIELD(0x014c, int8_t, tint_pad_4, [4])         \
-    FIELD(0x0150, float2x3, k, /*NO SUFFIX*/)      \
-    FIELD(0x0170, uint, l, /*NO SUFFIX*/)          \
-    FIELD(0x0174, int8_t, tint_pad_5, [12])        \
-    FIELD(0x0180, float2x4, m, /*NO SUFFIX*/)      \
-    FIELD(0x01a0, uint, n, /*NO SUFFIX*/)          \
-    FIELD(0x01a4, int8_t, tint_pad_6, [4])         \
-    FIELD(0x01a8, float3x2, o, /*NO SUFFIX*/)      \
-    FIELD(0x01c0, uint, p, /*NO SUFFIX*/)          \
-    FIELD(0x01c4, int8_t, tint_pad_7, [12])        \
-    FIELD(0x01d0, float3x3, q, /*NO SUFFIX*/)      \
-    FIELD(0x0200, uint, r, /*NO SUFFIX*/)          \
-    FIELD(0x0204, int8_t, tint_pad_8, [12])        \
-    FIELD(0x0210, float3x4, s, /*NO SUFFIX*/)      \
-    FIELD(0x0240, uint, t, /*NO SUFFIX*/)          \
-    FIELD(0x0244, int8_t, tint_pad_9, [4])         \
-    FIELD(0x0248, float4x2, u, /*NO SUFFIX*/)      \
-    FIELD(0x0268, uint, v, /*NO SUFFIX*/)          \
-    FIELD(0x026c, int8_t, tint_pad_10, [4])        \
-    FIELD(0x0270, float4x3, w, /*NO SUFFIX*/)      \
-    FIELD(0x02b0, uint, x, /*NO SUFFIX*/)          \
-    FIELD(0x02b4, int8_t, tint_pad_11, [12])       \
-    FIELD(0x02c0, float4x4, y, /*NO SUFFIX*/)      \
-    FIELD(0x0300, float, z, /*NO SUFFIX*/)         \
-    FIELD(0x0304, int8_t, tint_pad_12, [124])
+#define ALL_FIELDS()                       \
+    FIELD(0x0000, int, 0, a)               \
+    FIELD(0x0004, int8_t, 124, tint_pad)   \
+    FIELD(0x0080, float, 0, b)             \
+    FIELD(0x0084, int8_t, 124, tint_pad_1) \
+    FIELD(0x0100, float2, 0, c)            \
+    FIELD(0x0108, uint, 0, d)              \
+    FIELD(0x010c, int8_t, 4, tint_pad_2)   \
+    FIELD(0x0110, packed_float3, 0, e)     \
+    FIELD(0x011c, uint, 0, f)              \
+    FIELD(0x0120, float4, 0, g)            \
+    FIELD(0x0130, uint, 0, h)              \
+    FIELD(0x0134, int8_t, 4, tint_pad_3)   \
+    FIELD(0x0138, float2x2, 0, i)          \
+    FIELD(0x0148, uint, 0, j)              \
+    FIELD(0x014c, int8_t, 4, tint_pad_4)   \
+    FIELD(0x0150, float2x3, 0, k)          \
+    FIELD(0x0170, uint, 0, l)              \
+    FIELD(0x0174, int8_t, 12, tint_pad_5)  \
+    FIELD(0x0180, float2x4, 0, m)          \
+    FIELD(0x01a0, uint, 0, n)              \
+    FIELD(0x01a4, int8_t, 4, tint_pad_6)   \
+    FIELD(0x01a8, float3x2, 0, o)          \
+    FIELD(0x01c0, uint, 0, p)              \
+    FIELD(0x01c4, int8_t, 12, tint_pad_7)  \
+    FIELD(0x01d0, float3x3, 0, q)          \
+    FIELD(0x0200, uint, 0, r)              \
+    FIELD(0x0204, int8_t, 12, tint_pad_8)  \
+    FIELD(0x0210, float3x4, 0, s)          \
+    FIELD(0x0240, uint, 0, t)              \
+    FIELD(0x0244, int8_t, 4, tint_pad_9)   \
+    FIELD(0x0248, float4x2, 0, u)          \
+    FIELD(0x0268, uint, 0, v)              \
+    FIELD(0x026c, int8_t, 4, tint_pad_10)  \
+    FIELD(0x0270, float4x3, 0, w)          \
+    FIELD(0x02b0, uint, 0, x)              \
+    FIELD(0x02b4, int8_t, 12, tint_pad_11) \
+    FIELD(0x02c0, float4x4, 0, y)          \
+    FIELD(0x0300, float, 0, z)             \
+    FIELD(0x0304, int8_t, 124, tint_pad_12)
 
     // Check that the generated string is as expected.
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) "  /* " #ADDR " */ " #TYPE " " #NAME #SUFFIX ";\n"
-    auto* expect = "struct S {\n" ALL_FIELDS() "};\n";
+    std::stringstream expect;
+    expect << "struct S {\n";
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
+    FormatMSLField(expect, #ADDR, #TYPE, ARRAY_COUNT, #NAME);
+    ALL_FIELDS()
 #undef FIELD
-    EXPECT_EQ(buf.String(), expect);
+    expect << "};\n";
+    EXPECT_EQ(buf.String(), expect.str());
 
     // 1.4 Metal and C++14
     // The Metal programming language is a C++14-based Specification with
@@ -304,12 +322,12 @@
     // layout is as expected for C++14 / MSL.
     {
         struct S {
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) TYPE NAME SUFFIX;
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) std::array<TYPE, ARRAY_COUNT ? ARRAY_COUNT : 1> NAME;
             ALL_FIELDS()
 #undef FIELD
         };
 
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) \
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
     EXPECT_EQ(ADDR, static_cast<int>(offsetof(S, NAME))) << "Field " << #NAME;
         ALL_FIELDS()
 #undef FIELD
@@ -350,22 +368,26 @@
     auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
 
-    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, NAME, SUFFIX)
+    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
-#define ALL_FIELDS()                         \
-    FIELD(0x0000, int, a, /*NO SUFFIX*/)     \
-    FIELD(0x0004, int8_t, tint_pad, [508])   \
-    FIELD(0x0200, inner_x, b, /*NO SUFFIX*/) \
-    FIELD(0x0600, float, c, /*NO SUFFIX*/)   \
-    FIELD(0x0604, inner_y, d, /*NO SUFFIX*/) \
-    FIELD(0x0808, float, e, /*NO SUFFIX*/)   \
-    FIELD(0x080c, int8_t, tint_pad_1, [500])
+#define ALL_FIELDS()                     \
+    FIELD(0x0000, int, 0, a)             \
+    FIELD(0x0004, int8_t, 508, tint_pad) \
+    FIELD(0x0200, inner_x, 0, b)         \
+    FIELD(0x0600, float, 0, c)           \
+    FIELD(0x0604, inner_y, 0, d)         \
+    FIELD(0x0808, float, 0, e)           \
+    FIELD(0x080c, int8_t, 500, tint_pad_1)
 
     // Check that the generated string is as expected.
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) "  /* " #ADDR " */ " #TYPE " " #NAME #SUFFIX ";\n"
-    auto* expect = "struct S {\n" ALL_FIELDS() "};\n";
+    std::stringstream expect;
+    expect << "struct S {\n";
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
+    FormatMSLField(expect, #ADDR, #TYPE, ARRAY_COUNT, #NAME);
+    ALL_FIELDS()
 #undef FIELD
-    EXPECT_EQ(buf.String(), expect);
+    expect << "};\n";
+    EXPECT_EQ(buf.String(), expect.str());
 
     // 1.4 Metal and C++14
     // The Metal programming language is a C++14-based Specification with
@@ -389,12 +411,12 @@
         CHECK_TYPE_SIZE_AND_ALIGN(inner_y, 516, 4);
 
         struct S {
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) TYPE NAME SUFFIX;
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) std::array<TYPE, ARRAY_COUNT ? ARRAY_COUNT : 1> NAME;
             ALL_FIELDS()
 #undef FIELD
         };
 
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) \
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
     EXPECT_EQ(ADDR, static_cast<int>(offsetof(S, NAME))) << "Field " << #NAME;
         ALL_FIELDS()
 #undef FIELD
@@ -440,23 +462,27 @@
     auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
 
-    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, NAME, SUFFIX)
+    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
-#define ALL_FIELDS()                       \
-    FIELD(0x0000, int, a, /*NO SUFFIX*/)   \
-    FIELD(0x0004, float, b, [7])           \
-    FIELD(0x0020, float, c, /*NO SUFFIX*/) \
-    FIELD(0x0024, int8_t, tint_pad, [476]) \
-    FIELD(0x0200, inner, d, [4])           \
-    FIELD(0x1200, float, e, /*NO SUFFIX*/) \
-    FIELD(0x1204, float, f, [1])           \
-    FIELD(0x1208, int8_t, tint_pad_1, [504])
+#define ALL_FIELDS()                     \
+    FIELD(0x0000, int, 0, a)             \
+    FIELD(0x0004, float, 7, b)           \
+    FIELD(0x0020, float, 0, c)           \
+    FIELD(0x0024, int8_t, 476, tint_pad) \
+    FIELD(0x0200, inner, 4, d)           \
+    FIELD(0x1200, float, 0, e)           \
+    FIELD(0x1204, float, 1, f)           \
+    FIELD(0x1208, int8_t, 504, tint_pad_1)
 
     // Check that the generated string is as expected.
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) "  /* " #ADDR " */ " #TYPE " " #NAME #SUFFIX ";\n"
-    auto* expect = "struct S {\n" ALL_FIELDS() "};\n";
+    std::stringstream expect;
+    expect << "struct S {\n";
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
+    FormatMSLField(expect, #ADDR, #TYPE, ARRAY_COUNT, #NAME);
+    ALL_FIELDS()
 #undef FIELD
-    EXPECT_EQ(buf.String(), expect);
+    expect << "};\n";
+    EXPECT_EQ(buf.String(), expect.str());
 
     // 1.4 Metal and C++14
     // The Metal programming language is a C++14-based Specification with
@@ -486,12 +512,12 @@
         CHECK_TYPE_SIZE_AND_ALIGN(array_z, 4, 4);
 
         struct S {
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) TYPE NAME SUFFIX;
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) std::array<TYPE, ARRAY_COUNT ? ARRAY_COUNT : 1> NAME;
             ALL_FIELDS()
 #undef FIELD
         };
 
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) \
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
     EXPECT_EQ(ADDR, static_cast<int>(offsetof(S, NAME))) << "Field " << #NAME;
         ALL_FIELDS()
 #undef FIELD
@@ -522,20 +548,24 @@
     auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
 
-    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, NAME, SUFFIX)
+    // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
-#define ALL_FIELDS()                      \
-    FIELD(0x0000, int, a, /*NO SUFFIX*/)  \
-    FIELD(0x0004, int8_t, tint_pad, [12]) \
-    FIELD(0x0010, float3, b, [4])         \
-    FIELD(0x0050, int, c, /*NO SUFFIX*/)  \
-    FIELD(0x0054, int8_t, tint_pad_1, [12])
+#define ALL_FIELDS()                    \
+    FIELD(0x0000, int, 0, a)            \
+    FIELD(0x0004, int8_t, 12, tint_pad) \
+    FIELD(0x0010, float3, 4, b)         \
+    FIELD(0x0050, int, 0, c)            \
+    FIELD(0x0054, int8_t, 12, tint_pad_1)
 
     // Check that the generated string is as expected.
-#define FIELD(ADDR, TYPE, NAME, SUFFIX) "  /* " #ADDR " */ " #TYPE " " #NAME #SUFFIX ";\n"
-    auto* expect = "struct S {\n" ALL_FIELDS() "};\n";
+    std::stringstream expect;
+    expect << "struct S {\n";
+#define FIELD(ADDR, TYPE, ARRAY_COUNT, NAME) \
+    FormatMSLField(expect, #ADDR, #TYPE, ARRAY_COUNT, #NAME);
+    ALL_FIELDS()
 #undef FIELD
-    EXPECT_EQ(buf.String(), expect);
+    expect << "};\n";
+    EXPECT_EQ(buf.String(), expect.str());
 }
 
 TEST_F(MslGeneratorImplTest, AttemptTintPadSymbolCollision) {
@@ -583,44 +613,44 @@
     ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
     EXPECT_EQ(buf.String(), R"(struct S {
   /* 0x0000 */ int tint_pad_2;
-  /* 0x0004 */ int8_t tint_pad_10[124];
+  /* 0x0004 */ tint_array<int8_t, 124> tint_pad_10;
   /* 0x0080 */ float tint_pad_20;
-  /* 0x0084 */ int8_t tint_pad_11[124];
+  /* 0x0084 */ tint_array<int8_t, 124> tint_pad_11;
   /* 0x0100 */ float2 tint_pad_33;
   /* 0x0108 */ uint tint_pad_1;
-  /* 0x010c */ int8_t tint_pad_12[4];
+  /* 0x010c */ tint_array<int8_t, 4> tint_pad_12;
   /* 0x0110 */ packed_float3 tint_pad_3;
   /* 0x011c */ uint tint_pad_7;
   /* 0x0120 */ float4 tint_pad_25;
   /* 0x0130 */ uint tint_pad_5;
-  /* 0x0134 */ int8_t tint_pad_13[4];
+  /* 0x0134 */ tint_array<int8_t, 4> tint_pad_13;
   /* 0x0138 */ float2x2 tint_pad_27;
   /* 0x0148 */ uint tint_pad_24;
-  /* 0x014c */ int8_t tint_pad_14[4];
+  /* 0x014c */ tint_array<int8_t, 4> tint_pad_14;
   /* 0x0150 */ float2x3 tint_pad_23;
   /* 0x0170 */ uint tint_pad;
-  /* 0x0174 */ int8_t tint_pad_15[12];
+  /* 0x0174 */ tint_array<int8_t, 12> tint_pad_15;
   /* 0x0180 */ float2x4 tint_pad_8;
   /* 0x01a0 */ uint tint_pad_26;
-  /* 0x01a4 */ int8_t tint_pad_16[4];
+  /* 0x01a4 */ tint_array<int8_t, 4> tint_pad_16;
   /* 0x01a8 */ float3x2 tint_pad_29;
   /* 0x01c0 */ uint tint_pad_6;
-  /* 0x01c4 */ int8_t tint_pad_17[12];
+  /* 0x01c4 */ tint_array<int8_t, 12> tint_pad_17;
   /* 0x01d0 */ float3x3 tint_pad_22;
   /* 0x0200 */ uint tint_pad_32;
-  /* 0x0204 */ int8_t tint_pad_18[12];
+  /* 0x0204 */ tint_array<int8_t, 12> tint_pad_18;
   /* 0x0210 */ float3x4 tint_pad_34;
   /* 0x0240 */ uint tint_pad_35;
-  /* 0x0244 */ int8_t tint_pad_19[4];
+  /* 0x0244 */ tint_array<int8_t, 4> tint_pad_19;
   /* 0x0248 */ float4x2 tint_pad_30;
   /* 0x0268 */ uint tint_pad_9;
-  /* 0x026c */ int8_t tint_pad_36[4];
+  /* 0x026c */ tint_array<int8_t, 4> tint_pad_36;
   /* 0x0270 */ float4x3 tint_pad_31;
   /* 0x02b0 */ uint tint_pad_28;
-  /* 0x02b4 */ int8_t tint_pad_37[12];
+  /* 0x02b4 */ tint_array<int8_t, 12> tint_pad_37;
   /* 0x02c0 */ float4x4 tint_pad_4;
   /* 0x0300 */ float tint_pad_21;
-  /* 0x0304 */ int8_t tint_pad_38[124];
+  /* 0x0304 */ tint_array<int8_t, 124> tint_pad_38;
 };
 )");
 }
diff --git a/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc b/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc
index e41cc3b..f477572 100644
--- a/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc
+++ b/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc
@@ -61,7 +61,7 @@
     gen.increment_indent();
 
     ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
-    EXPECT_EQ(gen.result(), "  float a[5] = {0.0f};\n");
+    EXPECT_EQ(gen.result(), "  tint_array<float, 5> a = {};\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
diff --git a/test/tint/array/assign_to_function_var.wgsl.expected.msl b/test/tint/array/assign_to_function_var.wgsl.expected.msl
index 39cf432..dabd986 100644
--- a/test/tint/array/assign_to_function_var.wgsl.expected.msl
+++ b/test/tint/array/assign_to_function_var.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper arr;
+  /* 0x0000 */ tint_array<int4, 4> arr;
 };
 
-tint_array_wrapper ret_arr() {
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+tint_array<int4, 4> ret_arr() {
+  tint_array<int4, 4> const tint_symbol_1 = tint_array<int4, 4>{};
   return tint_symbol_1;
 }
 
@@ -19,26 +28,14 @@
   return tint_symbol_2;
 }
 
-struct tint_array_wrapper_3 {
-  int arr[2];
-};
-
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_3 arr[3];
-};
-
-struct tint_array_wrapper_1 {
-  tint_array_wrapper_2 arr[4];
-};
-
-void foo(tint_array_wrapper src_param, thread tint_array_wrapper* const tint_symbol_4, threadgroup tint_array_wrapper* const tint_symbol_5, const constant S* const tint_symbol_6, device S* const tint_symbol_7) {
-  tint_array_wrapper src_function = {};
-  tint_array_wrapper dst = {};
-  tint_array_wrapper const tint_symbol_3 = {.arr={int4(1), int4(2), int4(3), int4(3)}};
+void foo(tint_array<int4, 4> src_param, thread tint_array<int4, 4>* const tint_symbol_4, threadgroup tint_array<int4, 4>* const tint_symbol_5, const constant S* const tint_symbol_6, device S* const tint_symbol_7) {
+  tint_array<int4, 4> src_function = {};
+  tint_array<int4, 4> dst = {};
+  tint_array<int4, 4> const tint_symbol_3 = tint_array<int4, 4>{int4(1), int4(2), int4(3), int4(3)};
   dst = tint_symbol_3;
   dst = src_param;
   dst = ret_arr();
-  tint_array_wrapper const src_let = {.arr={}};
+  tint_array<int4, 4> const src_let = tint_array<int4, 4>{};
   dst = src_let;
   dst = src_function;
   dst = *(tint_symbol_4);
@@ -47,8 +44,8 @@
   dst = tint_symbol.arr;
   dst = (*(tint_symbol_6)).arr;
   dst = (*(tint_symbol_7)).arr;
-  tint_array_wrapper_1 dst_nested = {};
-  tint_array_wrapper_1 src_nested = {};
+  tint_array<tint_array<tint_array<int, 2>, 3>, 4> dst_nested = {};
+  tint_array<tint_array<tint_array<int, 2>, 3>, 4> src_nested = {};
   dst_nested = src_nested;
 }
 
diff --git a/test/tint/array/assign_to_private_var.wgsl.expected.msl b/test/tint/array/assign_to_private_var.wgsl.expected.msl
index be8972f..8ec45d8 100644
--- a/test/tint/array/assign_to_private_var.wgsl.expected.msl
+++ b/test/tint/array/assign_to_private_var.wgsl.expected.msl
@@ -1,28 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper arr;
+  /* 0x0000 */ tint_array<int4, 4> arr;
 };
 
-struct tint_array_wrapper_3 {
-  int arr[2];
-};
-
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_3 arr[3];
-};
-
-struct tint_array_wrapper_1 {
-  tint_array_wrapper_2 arr[4];
-};
-
-tint_array_wrapper ret_arr() {
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+tint_array<int4, 4> ret_arr() {
+  tint_array<int4, 4> const tint_symbol_1 = tint_array<int4, 4>{};
   return tint_symbol_1;
 }
 
@@ -31,13 +28,13 @@
   return tint_symbol_2;
 }
 
-void foo(tint_array_wrapper src_param, thread tint_array_wrapper* const tint_symbol_4, thread tint_array_wrapper* const tint_symbol_5, threadgroup tint_array_wrapper* const tint_symbol_6, const constant S* const tint_symbol_7, device S* const tint_symbol_8, thread tint_array_wrapper_1* const tint_symbol_9) {
-  tint_array_wrapper src_function = {};
-  tint_array_wrapper const tint_symbol_3 = {.arr={int4(1), int4(2), int4(3), int4(3)}};
+void foo(tint_array<int4, 4> src_param, thread tint_array<int4, 4>* const tint_symbol_4, thread tint_array<int4, 4>* const tint_symbol_5, threadgroup tint_array<int4, 4>* const tint_symbol_6, const constant S* const tint_symbol_7, device S* const tint_symbol_8, thread tint_array<tint_array<tint_array<int, 2>, 3>, 4>* const tint_symbol_9) {
+  tint_array<int4, 4> src_function = {};
+  tint_array<int4, 4> const tint_symbol_3 = tint_array<int4, 4>{int4(1), int4(2), int4(3), int4(3)};
   *(tint_symbol_4) = tint_symbol_3;
   *(tint_symbol_4) = src_param;
   *(tint_symbol_4) = ret_arr();
-  tint_array_wrapper const src_let = {.arr={}};
+  tint_array<int4, 4> const src_let = tint_array<int4, 4>{};
   *(tint_symbol_4) = src_let;
   *(tint_symbol_4) = src_function;
   *(tint_symbol_4) = *(tint_symbol_5);
@@ -46,7 +43,7 @@
   *(tint_symbol_4) = tint_symbol.arr;
   *(tint_symbol_4) = (*(tint_symbol_7)).arr;
   *(tint_symbol_4) = (*(tint_symbol_8)).arr;
-  tint_array_wrapper_1 src_nested = {};
+  tint_array<tint_array<tint_array<int, 2>, 3>, 4> src_nested = {};
   *(tint_symbol_9) = src_nested;
 }
 
diff --git a/test/tint/array/assign_to_storage_var.wgsl.expected.msl b/test/tint/array/assign_to_storage_var.wgsl.expected.msl
index 3bf3ccb..3165ec8 100644
--- a/test/tint/array/assign_to_storage_var.wgsl.expected.msl
+++ b/test/tint/array/assign_to_storage_var.wgsl.expected.msl
@@ -1,32 +1,29 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper arr;
-};
-
-struct tint_array_wrapper_3 {
-  /* 0x0000 */ int arr[2];
-};
-
-struct tint_array_wrapper_2 {
-  /* 0x0000 */ tint_array_wrapper_3 arr[3];
-};
-
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ tint_array_wrapper_2 arr[4];
+  /* 0x0000 */ tint_array<int4, 4> arr;
 };
 
 struct S_nested {
-  /* 0x0000 */ tint_array_wrapper_1 arr;
+  /* 0x0000 */ tint_array<tint_array<tint_array<int, 2>, 3>, 4> arr;
 };
 
-tint_array_wrapper ret_arr() {
-  tint_array_wrapper const tint_symbol_2 = {.arr={}};
+tint_array<int4, 4> ret_arr() {
+  tint_array<int4, 4> const tint_symbol_2 = tint_array<int4, 4>{};
   return tint_symbol_2;
 }
 
@@ -35,14 +32,14 @@
   return tint_symbol_3;
 }
 
-void foo(tint_array_wrapper src_param, device S* const tint_symbol_5, thread tint_array_wrapper* const tint_symbol_6, threadgroup tint_array_wrapper* const tint_symbol_7, const constant S* const tint_symbol_8, device S* const tint_symbol_9, device S_nested* const tint_symbol_10) {
-  tint_array_wrapper src_function = {};
-  tint_array_wrapper const tint_symbol_4 = {.arr={int4(1), int4(2), int4(3), int4(3)}};
+void foo(tint_array<int4, 4> src_param, device S* const tint_symbol_5, thread tint_array<int4, 4>* const tint_symbol_6, threadgroup tint_array<int4, 4>* const tint_symbol_7, const constant S* const tint_symbol_8, device S* const tint_symbol_9, device S_nested* const tint_symbol_10) {
+  tint_array<int4, 4> src_function = {};
+  tint_array<int4, 4> const tint_symbol_4 = tint_array<int4, 4>{int4(1), int4(2), int4(3), int4(3)};
   (*(tint_symbol_5)).arr = tint_symbol_4;
   (*(tint_symbol_5)).arr = src_param;
-  tint_array_wrapper const tint_symbol = ret_arr();
+  tint_array<int4, 4> const tint_symbol = ret_arr();
   (*(tint_symbol_5)).arr = tint_symbol;
-  tint_array_wrapper const src_let = {.arr={}};
+  tint_array<int4, 4> const src_let = tint_array<int4, 4>{};
   (*(tint_symbol_5)).arr = src_let;
   (*(tint_symbol_5)).arr = src_function;
   (*(tint_symbol_5)).arr = *(tint_symbol_6);
@@ -51,7 +48,7 @@
   (*(tint_symbol_5)).arr = tint_symbol_1.arr;
   (*(tint_symbol_5)).arr = (*(tint_symbol_8)).arr;
   (*(tint_symbol_5)).arr = (*(tint_symbol_9)).arr;
-  tint_array_wrapper_1 src_nested = {};
+  tint_array<tint_array<tint_array<int, 2>, 3>, 4> src_nested = {};
   (*(tint_symbol_10)).arr = src_nested;
 }
 
diff --git a/test/tint/array/assign_to_subexpr.wgsl.expected.msl b/test/tint/array/assign_to_subexpr.wgsl.expected.msl
index 735dc30..8851fcd 100644
--- a/test/tint/array/assign_to_subexpr.wgsl.expected.msl
+++ b/test/tint/array/assign_to_subexpr.wgsl.expected.msl
@@ -1,27 +1,32 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  tint_array_wrapper arr;
-};
-
-struct tint_array_wrapper_1 {
-  tint_array_wrapper arr[2];
+  tint_array<int, 4> arr;
 };
 
 void foo() {
-  tint_array_wrapper const src = {.arr={}};
-  tint_array_wrapper dst = {};
+  tint_array<int, 4> const src = tint_array<int, 4>{};
+  tint_array<int, 4> dst = {};
   S dst_struct = {};
-  tint_array_wrapper_1 dst_array = {};
+  tint_array<tint_array<int, 4>, 2> dst_array = {};
   dst_struct.arr = src;
-  dst_array.arr[1] = src;
+  dst_array[1] = src;
   dst = src;
   dst_struct.arr = src;
-  dst_array.arr[0] = src;
+  dst_array[0] = src;
 }
 
diff --git a/test/tint/array/assign_to_workgroup_var.wgsl.expected.msl b/test/tint/array/assign_to_workgroup_var.wgsl.expected.msl
index 9fab331..74df1bb 100644
--- a/test/tint/array/assign_to_workgroup_var.wgsl.expected.msl
+++ b/test/tint/array/assign_to_workgroup_var.wgsl.expected.msl
@@ -1,28 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper arr;
+  /* 0x0000 */ tint_array<int4, 4> arr;
 };
 
-struct tint_array_wrapper_3 {
-  int arr[2];
-};
-
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_3 arr[3];
-};
-
-struct tint_array_wrapper_1 {
-  tint_array_wrapper_2 arr[4];
-};
-
-tint_array_wrapper ret_arr() {
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+tint_array<int4, 4> ret_arr() {
+  tint_array<int4, 4> const tint_symbol_1 = tint_array<int4, 4>{};
   return tint_symbol_1;
 }
 
@@ -31,13 +28,13 @@
   return tint_symbol_2;
 }
 
-void foo(tint_array_wrapper src_param, threadgroup tint_array_wrapper* const tint_symbol_4, thread tint_array_wrapper* const tint_symbol_5, threadgroup tint_array_wrapper* const tint_symbol_6, const constant S* const tint_symbol_7, device S* const tint_symbol_8, threadgroup tint_array_wrapper_1* const tint_symbol_9) {
-  tint_array_wrapper src_function = {};
-  tint_array_wrapper const tint_symbol_3 = {.arr={int4(1), int4(2), int4(3), int4(3)}};
+void foo(tint_array<int4, 4> src_param, threadgroup tint_array<int4, 4>* const tint_symbol_4, thread tint_array<int4, 4>* const tint_symbol_5, threadgroup tint_array<int4, 4>* const tint_symbol_6, const constant S* const tint_symbol_7, device S* const tint_symbol_8, threadgroup tint_array<tint_array<tint_array<int, 2>, 3>, 4>* const tint_symbol_9) {
+  tint_array<int4, 4> src_function = {};
+  tint_array<int4, 4> const tint_symbol_3 = tint_array<int4, 4>{int4(1), int4(2), int4(3), int4(3)};
   *(tint_symbol_4) = tint_symbol_3;
   *(tint_symbol_4) = src_param;
   *(tint_symbol_4) = ret_arr();
-  tint_array_wrapper const src_let = {.arr={}};
+  tint_array<int4, 4> const src_let = tint_array<int4, 4>{};
   *(tint_symbol_4) = src_let;
   *(tint_symbol_4) = src_function;
   *(tint_symbol_4) = *(tint_symbol_5);
@@ -46,7 +43,7 @@
   *(tint_symbol_4) = tint_symbol.arr;
   *(tint_symbol_4) = (*(tint_symbol_7)).arr;
   *(tint_symbol_4) = (*(tint_symbol_8)).arr;
-  tint_array_wrapper_1 src_nested = {};
+  tint_array<tint_array<tint_array<int, 2>, 3>, 4> src_nested = {};
   *(tint_symbol_9) = src_nested;
 }
 
diff --git a/test/tint/array/function_parameter.wgsl.expected.msl b/test/tint/array/function_parameter.wgsl.expected.msl
index 277889e..bf68a61 100644
--- a/test/tint/array/function_parameter.wgsl.expected.msl
+++ b/test/tint/array/function_parameter.wgsl.expected.msl
@@ -1,34 +1,35 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-float f1(tint_array_wrapper a) {
-  return a.arr[3];
+float f1(tint_array<float, 4> a) {
+  return a[3];
 }
 
-struct tint_array_wrapper_1 {
-  tint_array_wrapper arr[3];
-};
-
-float f2(tint_array_wrapper_1 a) {
-  return a.arr[2].arr[3];
+float f2(tint_array<tint_array<float, 4>, 3> a) {
+  return a[2][3];
 }
 
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_1 arr[2];
-};
-
-float f3(tint_array_wrapper_2 a) {
-  return a.arr[1].arr[2].arr[3];
+float f3(tint_array<tint_array<tint_array<float, 4>, 3>, 2> a) {
+  return a[1][2][3];
 }
 
 kernel void tint_symbol() {
-  tint_array_wrapper const a1 = {.arr={}};
-  tint_array_wrapper_1 const a2 = {.arr={}};
-  tint_array_wrapper_2 const a3 = {.arr={}};
+  tint_array<float, 4> const a1 = tint_array<float, 4>{};
+  tint_array<tint_array<float, 4>, 3> const a2 = tint_array<tint_array<float, 4>, 3>{};
+  tint_array<tint_array<tint_array<float, 4>, 3>, 2> const a3 = tint_array<tint_array<tint_array<float, 4>, 3>, 2>{};
   float const v1 = f1(a1);
   float const v2 = f2(a2);
   float const v3 = f3(a3);
diff --git a/test/tint/array/function_return_type.wgsl.expected.msl b/test/tint/array/function_return_type.wgsl.expected.msl
index 8d7634a..703fc88 100644
--- a/test/tint/array/function_return_type.wgsl.expected.msl
+++ b/test/tint/array/function_return_type.wgsl.expected.msl
@@ -1,42 +1,43 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-tint_array_wrapper f1() {
-  tint_array_wrapper const tint_symbol_6 = {.arr={}};
+tint_array<float, 4> f1() {
+  tint_array<float, 4> const tint_symbol_6 = tint_array<float, 4>{};
   return tint_symbol_6;
 }
 
-struct tint_array_wrapper_1 {
-  tint_array_wrapper arr[3];
-};
-
-tint_array_wrapper_1 f2() {
-  tint_array_wrapper const tint_symbol_1 = f1();
-  tint_array_wrapper const tint_symbol_2 = f1();
-  tint_array_wrapper const tint_symbol_3 = f1();
-  tint_array_wrapper_1 const tint_symbol_7 = {.arr={tint_symbol_1, tint_symbol_2, tint_symbol_3}};
+tint_array<tint_array<float, 4>, 3> f2() {
+  tint_array<float, 4> const tint_symbol_1 = f1();
+  tint_array<float, 4> const tint_symbol_2 = f1();
+  tint_array<float, 4> const tint_symbol_3 = f1();
+  tint_array<tint_array<float, 4>, 3> const tint_symbol_7 = tint_array<tint_array<float, 4>, 3>{tint_symbol_1, tint_symbol_2, tint_symbol_3};
   return tint_symbol_7;
 }
 
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_1 arr[2];
-};
-
-tint_array_wrapper_2 f3() {
-  tint_array_wrapper_1 const tint_symbol_4 = f2();
-  tint_array_wrapper_1 const tint_symbol_5 = f2();
-  tint_array_wrapper_2 const tint_symbol_8 = {.arr={tint_symbol_4, tint_symbol_5}};
+tint_array<tint_array<tint_array<float, 4>, 3>, 2> f3() {
+  tint_array<tint_array<float, 4>, 3> const tint_symbol_4 = f2();
+  tint_array<tint_array<float, 4>, 3> const tint_symbol_5 = f2();
+  tint_array<tint_array<tint_array<float, 4>, 3>, 2> const tint_symbol_8 = tint_array<tint_array<tint_array<float, 4>, 3>, 2>{tint_symbol_4, tint_symbol_5};
   return tint_symbol_8;
 }
 
 kernel void tint_symbol() {
-  tint_array_wrapper const a1 = f1();
-  tint_array_wrapper_1 const a2 = f2();
-  tint_array_wrapper_2 const a3 = f3();
+  tint_array<float, 4> const a1 = f1();
+  tint_array<tint_array<float, 4>, 3> const a2 = f2();
+  tint_array<tint_array<tint_array<float, 4>, 3>, 2> const a3 = f3();
   return;
 }
 
diff --git a/test/tint/array/size.wgsl.expected.msl b/test/tint/array/size.wgsl.expected.msl
index 0150ece..27994b2 100644
--- a/test/tint/array/size.wgsl.expected.msl
+++ b/test/tint/array/size.wgsl.expected.msl
@@ -1,19 +1,28 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 constant int slen = 4;
 
 constant uint ulen = 4u;
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
 fragment void tint_symbol() {
-  tint_array_wrapper signed_literal = {};
-  tint_array_wrapper unsigned_literal = {};
-  tint_array_wrapper signed_constant = {};
-  tint_array_wrapper unsigned_constant = {};
+  tint_array<float, 4> signed_literal = {};
+  tint_array<float, 4> unsigned_literal = {};
+  tint_array<float, 4> signed_constant = {};
+  tint_array<float, 4> unsigned_constant = {};
   signed_literal = unsigned_constant;
   signed_constant = unsigned_literal;
   return;
diff --git a/test/tint/array/strides.spvasm.expected.msl b/test/tint/array/strides.spvasm.expected.msl
index 8db28bd..47d578e 100644
--- a/test/tint/array/strides.spvasm.expected.msl
+++ b/test/tint/array/strides.spvasm.expected.msl
@@ -1,40 +1,41 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct strided_arr {
   /* 0x0000 */ float el;
-  /* 0x0004 */ int8_t tint_pad[4];
-};
-
-struct tint_array_wrapper {
-  /* 0x0000 */ strided_arr arr[2];
-};
-
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ tint_array_wrapper arr[3];
+  /* 0x0004 */ tint_array<int8_t, 4> tint_pad;
 };
 
 struct strided_arr_1 {
-  /* 0x0000 */ tint_array_wrapper_1 el;
-  /* 0x0030 */ int8_t tint_pad_1[80];
-};
-
-struct tint_array_wrapper_2 {
-  /* 0x0000 */ strided_arr_1 arr[4];
+  /* 0x0000 */ tint_array<tint_array<strided_arr, 2>, 3> el;
+  /* 0x0030 */ tint_array<int8_t, 80> tint_pad_1;
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper_2 a;
+  /* 0x0000 */ tint_array<strided_arr_1, 4> a;
 };
 
 void f_1(device S* const tint_symbol_1) {
-  tint_array_wrapper_2 const x_19 = (*(tint_symbol_1)).a;
-  tint_array_wrapper_1 const x_24 = (*(tint_symbol_1)).a.arr[3].el;
-  tint_array_wrapper const x_28 = (*(tint_symbol_1)).a.arr[3].el.arr[2];
-  float const x_32 = (*(tint_symbol_1)).a.arr[3].el.arr[2].arr[1].el;
-  tint_array_wrapper_2 const tint_symbol = {.arr={}};
+  tint_array<strided_arr_1, 4> const x_19 = (*(tint_symbol_1)).a;
+  tint_array<tint_array<strided_arr, 2>, 3> const x_24 = (*(tint_symbol_1)).a[3].el;
+  tint_array<strided_arr, 2> const x_28 = (*(tint_symbol_1)).a[3].el[2];
+  float const x_32 = (*(tint_symbol_1)).a[3].el[2][1].el;
+  tint_array<strided_arr_1, 4> const tint_symbol = tint_array<strided_arr_1, 4>{};
   (*(tint_symbol_1)).a = tint_symbol;
-  (*(tint_symbol_1)).a.arr[3].el.arr[2].arr[1].el = 5.0f;
+  (*(tint_symbol_1)).a[3].el[2][1].el = 5.0f;
   return;
 }
 
diff --git a/test/tint/array/type_constructor.wgsl.expected.msl b/test/tint/array/type_constructor.wgsl.expected.msl
index 092ccee..efe30ae 100644
--- a/test/tint/array/type_constructor.wgsl.expected.msl
+++ b/test/tint/array/type_constructor.wgsl.expected.msl
@@ -1,56 +1,53 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[4];
-};
 
-struct tint_array_wrapper_2 {
-  tint_array_wrapper arr[3];
-};
-
-struct tint_array_wrapper_1 {
-  tint_array_wrapper_2 arr[2];
-};
-
-struct tint_array_wrapper_3 {
-  tint_array_wrapper arr[2];
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 kernel void tint_symbol() {
   int const x = 42;
-  tint_array_wrapper const empty = {.arr={}};
-  tint_array_wrapper const nonempty = {.arr={1, 2, 3, 4}};
-  tint_array_wrapper const nonempty_with_expr = {.arr={1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), nonempty.arr[3]}};
-  tint_array_wrapper_1 const nested_empty = {.arr={}};
-  tint_array_wrapper const tint_symbol_1 = {.arr={1, 2, 3, 4}};
-  tint_array_wrapper const tint_symbol_2 = {.arr={5, 6, 7, 8}};
-  tint_array_wrapper const tint_symbol_3 = {.arr={9, 10, 11, 12}};
-  tint_array_wrapper_2 const tint_symbol_4 = {.arr={tint_symbol_1, tint_symbol_2, tint_symbol_3}};
-  tint_array_wrapper const tint_symbol_5 = {.arr={13, 14, 15, 16}};
-  tint_array_wrapper const tint_symbol_6 = {.arr={17, 18, 19, 20}};
-  tint_array_wrapper const tint_symbol_7 = {.arr={21, 22, 23, 24}};
-  tint_array_wrapper_2 const tint_symbol_8 = {.arr={tint_symbol_5, tint_symbol_6, tint_symbol_7}};
-  tint_array_wrapper_1 const nested_nonempty = {.arr={tint_symbol_4, tint_symbol_8}};
-  tint_array_wrapper const tint_symbol_9 = {.arr={1, 2, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1)))}};
-  tint_array_wrapper const tint_symbol_10 = {.arr={5, 6, nonempty.arr[2], as_type<int>((as_type<uint>(nonempty.arr[3]) + as_type<uint>(1)))}};
-  tint_array_wrapper_2 const tint_symbol_11 = {.arr={tint_symbol_9, tint_symbol_10, nonempty}};
-  tint_array_wrapper_1 const nested_nonempty_with_expr = {.arr={tint_symbol_11, nested_nonempty.arr[1]}};
-  tint_array_wrapper const tint_symbol_12 = {.arr={}};
-  int const subexpr_empty = tint_symbol_12.arr[1];
-  tint_array_wrapper const tint_symbol_13 = {.arr={1, 2, 3, 4}};
-  int const subexpr_nonempty = tint_symbol_13.arr[2];
-  tint_array_wrapper const tint_symbol_14 = {.arr={1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), nonempty.arr[3]}};
-  int const subexpr_nonempty_with_expr = tint_symbol_14.arr[2];
-  tint_array_wrapper_3 const tint_symbol_15 = {.arr={}};
-  tint_array_wrapper const subexpr_nested_empty = tint_symbol_15.arr[1];
-  tint_array_wrapper const tint_symbol_16 = {.arr={1, 2, 3, 4}};
-  tint_array_wrapper const tint_symbol_17 = {.arr={5, 6, 7, 8}};
-  tint_array_wrapper_3 const tint_symbol_18 = {.arr={tint_symbol_16, tint_symbol_17}};
-  tint_array_wrapper const subexpr_nested_nonempty = tint_symbol_18.arr[1];
-  tint_array_wrapper const tint_symbol_19 = {.arr={1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), nonempty.arr[3]}};
-  tint_array_wrapper_3 const tint_symbol_20 = {.arr={tint_symbol_19, nested_nonempty.arr[1].arr[2]}};
-  tint_array_wrapper const subexpr_nested_nonempty_with_expr = tint_symbol_20.arr[1];
+  tint_array<int, 4> const empty = tint_array<int, 4>{};
+  tint_array<int, 4> const nonempty = tint_array<int, 4>{1, 2, 3, 4};
+  tint_array<int, 4> const nonempty_with_expr = tint_array<int, 4>{1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), 4};
+  tint_array<tint_array<tint_array<int, 4>, 3>, 2> const nested_empty = tint_array<tint_array<tint_array<int, 4>, 3>, 2>{};
+  tint_array<int, 4> const tint_symbol_1 = tint_array<int, 4>{1, 2, 3, 4};
+  tint_array<int, 4> const tint_symbol_2 = tint_array<int, 4>{5, 6, 7, 8};
+  tint_array<int, 4> const tint_symbol_3 = tint_array<int, 4>{9, 10, 11, 12};
+  tint_array<tint_array<int, 4>, 3> const tint_symbol_4 = tint_array<tint_array<int, 4>, 3>{tint_symbol_1, tint_symbol_2, tint_symbol_3};
+  tint_array<int, 4> const tint_symbol_5 = tint_array<int, 4>{13, 14, 15, 16};
+  tint_array<int, 4> const tint_symbol_6 = tint_array<int, 4>{17, 18, 19, 20};
+  tint_array<int, 4> const tint_symbol_7 = tint_array<int, 4>{21, 22, 23, 24};
+  tint_array<tint_array<int, 4>, 3> const tint_symbol_8 = tint_array<tint_array<int, 4>, 3>{tint_symbol_5, tint_symbol_6, tint_symbol_7};
+  tint_array<tint_array<tint_array<int, 4>, 3>, 2> const nested_nonempty = tint_array<tint_array<tint_array<int, 4>, 3>, 2>{tint_symbol_4, tint_symbol_8};
+  tint_array<int, 4> const tint_symbol_9 = tint_array<int, 4>{1, 2, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1)))};
+  tint_array<int, 4> const tint_symbol_10 = tint_array<int, 4>{5, 6, 3, as_type<int>((as_type<uint>(4) + as_type<uint>(1)))};
+  tint_array<tint_array<int, 4>, 3> const tint_symbol_11 = tint_array<tint_array<int, 4>, 3>{tint_symbol_9, tint_symbol_10, nonempty};
+  tint_array<tint_array<tint_array<int, 4>, 3>, 2> const nested_nonempty_with_expr = tint_array<tint_array<tint_array<int, 4>, 3>, 2>{tint_symbol_11, nested_nonempty[1]};
+  tint_array<int, 4> const tint_symbol_12 = tint_array<int, 4>{};
+  int const subexpr_empty = 0;
+  tint_array<int, 4> const tint_symbol_13 = tint_array<int, 4>{1, 2, 3, 4};
+  int const subexpr_nonempty = 3;
+  tint_array<int, 4> const tint_symbol_14 = tint_array<int, 4>{1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), 4};
+  int const subexpr_nonempty_with_expr = tint_symbol_14[2];
+  tint_array<tint_array<int, 4>, 2> const tint_symbol_15 = tint_array<tint_array<int, 4>, 2>{};
+  tint_array<int, 4> const subexpr_nested_empty = tint_symbol_15[1];
+  tint_array<int, 4> const tint_symbol_16 = tint_array<int, 4>{1, 2, 3, 4};
+  tint_array<int, 4> const tint_symbol_17 = tint_array<int, 4>{5, 6, 7, 8};
+  tint_array<tint_array<int, 4>, 2> const tint_symbol_18 = tint_array<tint_array<int, 4>, 2>{tint_symbol_16, tint_symbol_17};
+  tint_array<int, 4> const subexpr_nested_nonempty = tint_symbol_18[1];
+  tint_array<int, 4> const tint_symbol_19 = tint_array<int, 4>{1, 42, as_type<int>((as_type<uint>(42) + as_type<uint>(1))), 4};
+  tint_array<tint_array<int, 4>, 2> const tint_symbol_20 = tint_array<tint_array<int, 4>, 2>{tint_symbol_19, nested_nonempty[1][2]};
+  tint_array<int, 4> const subexpr_nested_nonempty_with_expr = tint_symbol_20[1];
   return;
 }
 
diff --git a/test/tint/buffer/storage/dynamic_index/read.wgsl.expected.msl b/test/tint/buffer/storage/dynamic_index/read.wgsl.expected.msl
index 530148b..549e70f 100644
--- a/test/tint/buffer/storage/dynamic_index/read.wgsl.expected.msl
+++ b/test/tint/buffer/storage/dynamic_index/read.wgsl.expected.msl
@@ -12,8 +12,16 @@
   return vec<T, M>(lhs) * rhs;
 }
 
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct Inner {
@@ -25,12 +33,12 @@
   /* 0x002c */ float f;
   /* 0x0030 */ float2x3 g;
   /* 0x0050 */ float3x2 h;
-  /* 0x0068 */ int8_t tint_pad[8];
-  /* 0x0070 */ tint_array_wrapper i;
+  /* 0x0068 */ tint_array<int8_t, 8> tint_pad;
+  /* 0x0070 */ tint_array<int4, 4> i;
 };
 
 struct S {
-  /* 0x0000 */ Inner arr[1];
+  /* 0x0000 */ tint_array<Inner, 1> arr;
 };
 
 void tint_symbol_inner(uint idx, const device S* const tint_symbol_1) {
@@ -42,7 +50,7 @@
   float const f = (*(tint_symbol_1)).arr[idx].f;
   float2x3 const g = (*(tint_symbol_1)).arr[idx].g;
   float3x2 const h = (*(tint_symbol_1)).arr[idx].h;
-  tint_array_wrapper const i = (*(tint_symbol_1)).arr[idx].i;
+  tint_array<int4, 4> const i = (*(tint_symbol_1)).arr[idx].i;
 }
 
 kernel void tint_symbol(const device S* tint_symbol_2 [[buffer(0)]], uint idx [[thread_index_in_threadgroup]]) {
diff --git a/test/tint/buffer/storage/dynamic_index/write.wgsl.expected.msl b/test/tint/buffer/storage/dynamic_index/write.wgsl.expected.msl
index 291f5a9..e2430df 100644
--- a/test/tint/buffer/storage/dynamic_index/write.wgsl.expected.msl
+++ b/test/tint/buffer/storage/dynamic_index/write.wgsl.expected.msl
@@ -12,8 +12,16 @@
   return vec<T, M>(lhs) * rhs;
 }
 
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct Inner {
@@ -25,12 +33,12 @@
   /* 0x002c */ float f;
   /* 0x0030 */ float2x3 g;
   /* 0x0050 */ float3x2 h;
-  /* 0x0068 */ int8_t tint_pad[8];
-  /* 0x0070 */ tint_array_wrapper i;
+  /* 0x0068 */ tint_array<int8_t, 8> tint_pad;
+  /* 0x0070 */ tint_array<int4, 4> i;
 };
 
 struct S {
-  /* 0x0000 */ Inner arr[1];
+  /* 0x0000 */ tint_array<Inner, 1> arr;
 };
 
 void tint_symbol_inner(uint idx, device S* const tint_symbol_2) {
@@ -42,7 +50,7 @@
   (*(tint_symbol_2)).arr[idx].f = 0.0f;
   (*(tint_symbol_2)).arr[idx].g = float2x3(float3(0.0f), float3(0.0f));
   (*(tint_symbol_2)).arr[idx].h = float3x2(float2(0.0f), float2(0.0f), float2(0.0f));
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+  tint_array<int4, 4> const tint_symbol_1 = tint_array<int4, 4>{};
   (*(tint_symbol_2)).arr[idx].i = tint_symbol_1;
 }
 
diff --git a/test/tint/buffer/storage/static_index/read.wgsl.expected.msl b/test/tint/buffer/storage/static_index/read.wgsl.expected.msl
index 8a4f444..8f891a2 100644
--- a/test/tint/buffer/storage/static_index/read.wgsl.expected.msl
+++ b/test/tint/buffer/storage/static_index/read.wgsl.expected.msl
@@ -12,12 +12,20 @@
   return vec<T, M>(lhs) * rhs;
 }
 
-struct Inner {
-  /* 0x0000 */ int x;
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ Inner arr[4];
+struct Inner {
+  /* 0x0000 */ int x;
 };
 
 struct S {
@@ -30,8 +38,8 @@
   /* 0x0030 */ float2x3 g;
   /* 0x0050 */ float3x2 h;
   /* 0x0068 */ Inner i;
-  /* 0x006c */ tint_array_wrapper j;
-  /* 0x007c */ int8_t tint_pad[4];
+  /* 0x006c */ tint_array<Inner, 4> j;
+  /* 0x007c */ tint_array<int8_t, 4> tint_pad;
 };
 
 kernel void tint_symbol(const device S* tint_symbol_1 [[buffer(0)]]) {
@@ -44,7 +52,7 @@
   float2x3 const g = (*(tint_symbol_1)).g;
   float3x2 const h = (*(tint_symbol_1)).h;
   Inner const i = (*(tint_symbol_1)).i;
-  tint_array_wrapper const j = (*(tint_symbol_1)).j;
+  tint_array<Inner, 4> const j = (*(tint_symbol_1)).j;
   return;
 }
 
diff --git a/test/tint/buffer/storage/static_index/write.wgsl.expected.msl b/test/tint/buffer/storage/static_index/write.wgsl.expected.msl
index ae3ab67..afb9718 100644
--- a/test/tint/buffer/storage/static_index/write.wgsl.expected.msl
+++ b/test/tint/buffer/storage/static_index/write.wgsl.expected.msl
@@ -12,12 +12,20 @@
   return vec<T, M>(lhs) * rhs;
 }
 
-struct Inner {
-  /* 0x0000 */ int x;
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ Inner arr[4];
+struct Inner {
+  /* 0x0000 */ int x;
 };
 
 struct S {
@@ -30,8 +38,8 @@
   /* 0x0030 */ float2x3 g;
   /* 0x0050 */ float3x2 h;
   /* 0x0068 */ Inner i;
-  /* 0x006c */ tint_array_wrapper j;
-  /* 0x007c */ int8_t tint_pad[4];
+  /* 0x006c */ tint_array<Inner, 4> j;
+  /* 0x007c */ tint_array<int8_t, 4> tint_pad;
 };
 
 kernel void tint_symbol(device S* tint_symbol_3 [[buffer(0)]]) {
@@ -45,7 +53,7 @@
   (*(tint_symbol_3)).h = float3x2(float2(0.0f), float2(0.0f), float2(0.0f));
   Inner const tint_symbol_1 = {};
   (*(tint_symbol_3)).i = tint_symbol_1;
-  tint_array_wrapper const tint_symbol_2 = {.arr={}};
+  tint_array<Inner, 4> const tint_symbol_2 = tint_array<Inner, 4>{};
   (*(tint_symbol_3)).j = tint_symbol_2;
   return;
 }
diff --git a/test/tint/buffer/storage/types/array.wgsl.expected.msl b/test/tint/buffer/storage/types/array.wgsl.expected.msl
index 685b94a..9155f75 100644
--- a/test/tint/buffer/storage/types/array.wgsl.expected.msl
+++ b/test/tint/buffer/storage/types/array.wgsl.expected.msl
@@ -1,11 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ float arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-kernel void tint_symbol(device tint_array_wrapper* tint_symbol_1 [[buffer(0)]], const device tint_array_wrapper* tint_symbol_2 [[buffer(1)]]) {
+kernel void tint_symbol(device tint_array<float, 4>* tint_symbol_1 [[buffer(0)]], const device tint_array<float, 4>* tint_symbol_2 [[buffer(1)]]) {
   *(tint_symbol_1) = *(tint_symbol_2);
   return;
 }
diff --git a/test/tint/buffer/storage/types/runtime_array.wgsl.expected.msl b/test/tint/buffer/storage/types/runtime_array.wgsl.expected.msl
index 47fcb21..836dba1 100644
--- a/test/tint/buffer/storage/types/runtime_array.wgsl.expected.msl
+++ b/test/tint/buffer/storage/types/runtime_array.wgsl.expected.msl
@@ -1,16 +1,29 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ float f;
 };
 
 struct tint_symbol_2 {
-  /* 0x0000 */ S arr[1];
+  /* 0x0000 */ tint_array<S, 1> arr;
 };
 
 struct tint_symbol_4 {
-  /* 0x0000 */ S arr[1];
+  /* 0x0000 */ tint_array<S, 1> arr;
 };
 
 kernel void tint_symbol(device tint_symbol_2* tint_symbol_1 [[buffer(0)]], const device tint_symbol_4* tint_symbol_3 [[buffer(1)]]) {
diff --git a/test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.msl b/test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.msl
index d781b86..e361022 100644
--- a/test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.msl
+++ b/test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.msl
@@ -12,8 +12,16 @@
   return vec<T, M>(lhs) * rhs;
 }
 
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct Inner {
@@ -27,30 +35,26 @@
   /* 0x0038 */ int2 h;
   /* 0x0040 */ float2x3 i;
   /* 0x0060 */ float3x2 j;
-  /* 0x0078 */ int8_t tint_pad[8];
-  /* 0x0080 */ tint_array_wrapper k;
-};
-
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ Inner arr[8];
+  /* 0x0078 */ tint_array<int8_t, 8> tint_pad;
+  /* 0x0080 */ tint_array<int4, 4> k;
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper_1 arr;
+  /* 0x0000 */ tint_array<Inner, 8> arr;
 };
 
 void tint_symbol_inner(uint idx, const constant S* const tint_symbol_1) {
-  int3 const a = (*(tint_symbol_1)).arr.arr[idx].a;
-  int const b = (*(tint_symbol_1)).arr.arr[idx].b;
-  uint3 const c = (*(tint_symbol_1)).arr.arr[idx].c;
-  uint const d = (*(tint_symbol_1)).arr.arr[idx].d;
-  float3 const e = (*(tint_symbol_1)).arr.arr[idx].e;
-  float const f = (*(tint_symbol_1)).arr.arr[idx].f;
-  int2 const g = (*(tint_symbol_1)).arr.arr[idx].g;
-  int2 const h = (*(tint_symbol_1)).arr.arr[idx].h;
-  float2x3 const i = (*(tint_symbol_1)).arr.arr[idx].i;
-  float3x2 const j = (*(tint_symbol_1)).arr.arr[idx].j;
-  tint_array_wrapper const k = (*(tint_symbol_1)).arr.arr[idx].k;
+  int3 const a = (*(tint_symbol_1)).arr[idx].a;
+  int const b = (*(tint_symbol_1)).arr[idx].b;
+  uint3 const c = (*(tint_symbol_1)).arr[idx].c;
+  uint const d = (*(tint_symbol_1)).arr[idx].d;
+  float3 const e = (*(tint_symbol_1)).arr[idx].e;
+  float const f = (*(tint_symbol_1)).arr[idx].f;
+  int2 const g = (*(tint_symbol_1)).arr[idx].g;
+  int2 const h = (*(tint_symbol_1)).arr[idx].h;
+  float2x3 const i = (*(tint_symbol_1)).arr[idx].i;
+  float3x2 const j = (*(tint_symbol_1)).arr[idx].j;
+  tint_array<int4, 4> const k = (*(tint_symbol_1)).arr[idx].k;
 }
 
 kernel void tint_symbol(const constant S* tint_symbol_2 [[buffer(0)]], uint idx [[thread_index_in_threadgroup]]) {
diff --git a/test/tint/buffer/uniform/static_index/read.wgsl.expected.msl b/test/tint/buffer/uniform/static_index/read.wgsl.expected.msl
index 26abf26..26497bd 100644
--- a/test/tint/buffer/uniform/static_index/read.wgsl.expected.msl
+++ b/test/tint/buffer/uniform/static_index/read.wgsl.expected.msl
@@ -2,6 +2,18 @@
 
 using namespace metal;
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 template<typename T, int N, int M>
 inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
   return lhs * vec<T, N>(rhs);
@@ -14,11 +26,7 @@
 
 struct Inner {
   /* 0x0000 */ int x;
-  /* 0x0004 */ int8_t tint_pad[12];
-};
-
-struct tint_array_wrapper {
-  /* 0x0000 */ Inner arr[4];
+  /* 0x0004 */ tint_array<int8_t, 12> tint_pad;
 };
 
 struct S {
@@ -32,9 +40,9 @@
   /* 0x0038 */ int2 h;
   /* 0x0040 */ float2x3 i;
   /* 0x0060 */ float3x2 j;
-  /* 0x0078 */ int8_t tint_pad_1[8];
+  /* 0x0078 */ tint_array<int8_t, 8> tint_pad_1;
   /* 0x0080 */ Inner k;
-  /* 0x0090 */ tint_array_wrapper l;
+  /* 0x0090 */ tint_array<Inner, 4> l;
 };
 
 kernel void tint_symbol(const constant S* tint_symbol_1 [[buffer(0)]]) {
@@ -49,7 +57,7 @@
   float2x3 const i = (*(tint_symbol_1)).i;
   float3x2 const j = (*(tint_symbol_1)).j;
   Inner const k = (*(tint_symbol_1)).k;
-  tint_array_wrapper const l = (*(tint_symbol_1)).l;
+  tint_array<Inner, 4> const l = (*(tint_symbol_1)).l;
   return;
 }
 
diff --git a/test/tint/buffer/uniform/types/array.wgsl.expected.msl b/test/tint/buffer/uniform/types/array.wgsl.expected.msl
index 71c0b99..730f4b1 100644
--- a/test/tint/buffer/uniform/types/array.wgsl.expected.msl
+++ b/test/tint/buffer/uniform/types/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ float4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-kernel void tint_symbol(const constant tint_array_wrapper* tint_symbol_1 [[buffer(0)]]) {
-  tint_array_wrapper const x = *(tint_symbol_1);
+kernel void tint_symbol(const constant tint_array<float4, 4>* tint_symbol_1 [[buffer(0)]]) {
+  tint_array<float4, 4> const x = *(tint_symbol_1);
   return;
 }
 
diff --git a/test/tint/bug/chromium/1273230.wgsl.expected.msl b/test/tint/bug/chromium/1273230.wgsl.expected.msl
index 0052f59..08f7854 100644
--- a/test/tint/bug/chromium/1273230.wgsl.expected.msl
+++ b/test/tint/bug/chromium/1273230.wgsl.expected.msl
@@ -12,6 +12,18 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 void marg8uintin() {
 }
 
@@ -21,9 +33,9 @@
   /* 0x0008 */ uint puuuuuuuuuuuuuuuuad1;
   /* 0x000c */ uint pad2;
   /* 0x0010 */ packed_float3 bbMin;
-  /* 0x001c */ int8_t tint_pad[4];
+  /* 0x001c */ tint_array<int8_t, 4> tint_pad;
   /* 0x0020 */ packed_float3 bbMax;
-  /* 0x002c */ int8_t tint_pad_1[4];
+  /* 0x002c */ tint_array<int8_t, 4> tint_pad_1;
 };
 
 struct Dbg {
@@ -42,23 +54,23 @@
 };
 
 struct F32s {
-  /* 0x0000 */ float values[1];
+  /* 0x0000 */ tint_array<float, 1> values;
 };
 
 struct U32s {
-  /* 0x0000 */ uint values[1];
+  /* 0x0000 */ tint_array<uint, 1> values;
 };
 
 struct I32s {
-  int values[1];
+  tint_array<int, 1> values;
 };
 
 struct AU32s {
-  /* 0x0000 */ atomic_uint values[1];
+  /* 0x0000 */ tint_array<atomic_uint, 1> values;
 };
 
 struct AI32s {
-  /* 0x0000 */ atomic_int values[1];
+  /* 0x0000 */ tint_array<atomic_int, 1> values;
 };
 
 float3 toVoxelPos(float3 position, const constant Uniforms* const tint_symbol) {
diff --git a/test/tint/bug/chromium/1290107.wgsl.expected.msl b/test/tint/bug/chromium/1290107.wgsl.expected.msl
index 5b9d426..de7b6e3 100644
--- a/test/tint/bug/chromium/1290107.wgsl.expected.msl
+++ b/test/tint/bug/chromium/1290107.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
diff --git a/test/tint/bug/dawn/947.wgsl.expected.msl b/test/tint/bug/dawn/947.wgsl.expected.msl
index f65b451..68d2045 100644
--- a/test/tint/bug/dawn/947.wgsl.expected.msl
+++ b/test/tint/bug/dawn/947.wgsl.expected.msl
@@ -13,6 +13,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ float2 u_scale;
   /* 0x0008 */ float2 u_offset;
@@ -28,19 +41,15 @@
   float4 position [[position]];
 };
 
-struct tint_array_wrapper {
-  float2 arr[3];
-};
-
 VertexOutputs vs_main_inner(uint VertexIndex, const constant Uniforms* const tint_symbol_5) {
-  tint_array_wrapper texcoord = {.arr={float2(-0.5f, 0.0f), float2(1.5f, 0.0f), float2(0.5f, 2.0f)}};
+  tint_array<float2, 3> texcoord = tint_array<float2, 3>{float2(-0.5f, 0.0f), float2(1.5f, 0.0f), float2(0.5f, 2.0f)};
   VertexOutputs output = {};
-  output.position = float4(((texcoord.arr[VertexIndex] * 2.0f) - float2(1.0f)), 0.0f, 1.0f);
+  output.position = float4(((texcoord[VertexIndex] * 2.0f) - float2(1.0f)), 0.0f, 1.0f);
   bool flipY = ((*(tint_symbol_5)).u_scale[1] < 0.0f);
   if (flipY) {
-    output.texcoords = ((((texcoord.arr[VertexIndex] * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset) * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f));
+    output.texcoords = ((((texcoord[VertexIndex] * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset) * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f));
   } else {
-    output.texcoords = ((((texcoord.arr[VertexIndex] * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f)) * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset);
+    output.texcoords = ((((texcoord[VertexIndex] * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f)) * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset);
   }
   return output;
 }
diff --git a/test/tint/bug/fxc/dyn_array_idx/read/function.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/read/function.wgsl.expected.msl
index 271eaa1..8f724a6 100644
--- a/test/tint/bug/fxc/dyn_array_idx/read/function.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/read/function.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -19,7 +28,7 @@
 
 kernel void f(device Result* tint_symbol [[buffer(1)]], const constant UBO* tint_symbol_1 [[buffer(0)]]) {
   S s = {};
-  (*(tint_symbol)).out = s.data.arr[(*(tint_symbol_1)).dynamic_idx];
+  (*(tint_symbol)).out = s.data[(*(tint_symbol_1)).dynamic_idx];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/read/private.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/read/private.wgsl.expected.msl
index 00b6f03..8ac8114 100644
--- a/test/tint/bug/fxc/dyn_array_idx/read/private.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/read/private.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -19,7 +28,7 @@
 
 kernel void f(device Result* tint_symbol [[buffer(1)]], const constant UBO* tint_symbol_2 [[buffer(0)]]) {
   thread S tint_symbol_1 = {};
-  (*(tint_symbol)).out = tint_symbol_1.data.arr[(*(tint_symbol_2)).dynamic_idx];
+  (*(tint_symbol)).out = tint_symbol_1.data[(*(tint_symbol_2)).dynamic_idx];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/read/storage.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/read/storage.wgsl.expected.msl
index 92fb6e6..c802c8f 100644
--- a/test/tint/bug/fxc/dyn_array_idx/read/storage.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/read/storage.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
@@ -9,16 +22,12 @@
   /* 0x0000 */ int out;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ int arr[4];
-};
-
 struct SSBO {
-  /* 0x0000 */ tint_array_wrapper data;
+  /* 0x0000 */ tint_array<int, 4> data;
 };
 
 kernel void f(device Result* tint_symbol [[buffer(1)]], device SSBO* tint_symbol_1 [[buffer(2)]], const constant UBO* tint_symbol_2 [[buffer(0)]]) {
-  (*(tint_symbol)).out = (*(tint_symbol_1)).data.arr[(*(tint_symbol_2)).dynamic_idx];
+  (*(tint_symbol)).out = (*(tint_symbol_1)).data[(*(tint_symbol_2)).dynamic_idx];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/read/uniform.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/read/uniform.wgsl.expected.msl
index 48d71be..c9ab959 100644
--- a/test/tint/bug/fxc/dyn_array_idx/read/uniform.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/read/uniform.wgsl.expected.msl
@@ -1,14 +1,23 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct UBO {
-  /* 0x0000 */ tint_array_wrapper data;
+  /* 0x0000 */ tint_array<int4, 4> data;
   /* 0x0040 */ int dynamic_idx;
-  /* 0x0044 */ int8_t tint_pad[12];
+  /* 0x0044 */ tint_array<int8_t, 12> tint_pad;
 };
 
 struct Result {
@@ -16,7 +25,7 @@
 };
 
 kernel void f(device Result* tint_symbol [[buffer(1)]], const constant UBO* tint_symbol_1 [[buffer(0)]]) {
-  (*(tint_symbol)).out = (*(tint_symbol_1)).data.arr[(*(tint_symbol_1)).dynamic_idx][0];
+  (*(tint_symbol)).out = (*(tint_symbol_1)).data[(*(tint_symbol_1)).dynamic_idx][0];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/read/workgroup.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/read/workgroup.wgsl.expected.msl
index 2566aba..b8557fd 100644
--- a/test/tint/bug/fxc/dyn_array_idx/read/workgroup.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/read/workgroup.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -20,10 +29,10 @@
 void f_inner(uint local_invocation_index, threadgroup S* const tint_symbol, device Result* const tint_symbol_1, const constant UBO* const tint_symbol_2) {
   for(uint idx = local_invocation_index; (idx < 64u); idx = (idx + 1u)) {
     uint const i = idx;
-    (*(tint_symbol)).data.arr[i] = 0;
+    (*(tint_symbol)).data[i] = 0;
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
-  (*(tint_symbol_1)).out = (*(tint_symbol)).data.arr[(*(tint_symbol_2)).dynamic_idx];
+  (*(tint_symbol_1)).out = (*(tint_symbol)).data[(*(tint_symbol_2)).dynamic_idx];
 }
 
 kernel void f(device Result* tint_symbol_4 [[buffer(1)]], const constant UBO* tint_symbol_5 [[buffer(0)]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/function.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/function.wgsl.expected.msl
index c4e1dff..1fe02f1 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/function.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/function.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -19,8 +28,8 @@
 
 kernel void f(const constant UBO* tint_symbol [[buffer(0)]], device Result* tint_symbol_1 [[buffer(1)]]) {
   S s = {};
-  s.data.arr[(*(tint_symbol)).dynamic_idx] = 1;
-  (*(tint_symbol_1)).out = s.data.arr[3];
+  s.data[(*(tint_symbol)).dynamic_idx] = 1;
+  (*(tint_symbol_1)).out = s.data[3];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/function_via_param.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/function_via_param.wgsl.expected.msl
index b9efff8..5aabd3a 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/function_via_param.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/function_via_param.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -18,13 +27,13 @@
 };
 
 void x(thread S* const p, const constant UBO* const tint_symbol) {
-  (*(p)).data.arr[(*(tint_symbol)).dynamic_idx] = 1;
+  (*(p)).data[(*(tint_symbol)).dynamic_idx] = 1;
 }
 
 kernel void f(const constant UBO* tint_symbol_1 [[buffer(0)]], device Result* tint_symbol_2 [[buffer(1)]]) {
   S s = {};
   x(&(s), tint_symbol_1);
-  (*(tint_symbol_2)).out = s.data.arr[3];
+  (*(tint_symbol_2)).out = s.data[3];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/private.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/private.wgsl.expected.msl
index 2a59ee4..6f94f24 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/private.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/private.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -19,8 +28,8 @@
 
 kernel void f(const constant UBO* tint_symbol_1 [[buffer(0)]], device Result* tint_symbol_2 [[buffer(1)]]) {
   thread S tint_symbol = {};
-  tint_symbol.data.arr[(*(tint_symbol_1)).dynamic_idx] = 1;
-  (*(tint_symbol_2)).out = tint_symbol.data.arr[3];
+  tint_symbol.data[(*(tint_symbol_1)).dynamic_idx] = 1;
+  (*(tint_symbol_2)).out = tint_symbol.data[3];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/private_via_param.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/private_via_param.wgsl.expected.msl
index a27679e..0a31f28 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/private_via_param.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/private_via_param.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -18,13 +27,13 @@
 };
 
 void x(thread S* const p, const constant UBO* const tint_symbol) {
-  (*(p)).data.arr[(*(tint_symbol)).dynamic_idx] = 1;
+  (*(p)).data[(*(tint_symbol)).dynamic_idx] = 1;
 }
 
 kernel void f(const constant UBO* tint_symbol_2 [[buffer(0)]], device Result* tint_symbol_3 [[buffer(1)]]) {
   thread S tint_symbol_1 = {};
   x(&(tint_symbol_1), tint_symbol_2);
-  (*(tint_symbol_3)).out = tint_symbol_1.data.arr[3];
+  (*(tint_symbol_3)).out = tint_symbol_1.data[3];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/storage.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/storage.wgsl.expected.msl
index ca1afb5..747fc40 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/storage.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/storage.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
@@ -9,17 +22,13 @@
   /* 0x0000 */ int out;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ int arr[4];
-};
-
 struct SSBO {
-  /* 0x0000 */ tint_array_wrapper data;
+  /* 0x0000 */ tint_array<int, 4> data;
 };
 
 kernel void f(device SSBO* tint_symbol [[buffer(1)]], const constant UBO* tint_symbol_1 [[buffer(0)]], device Result* tint_symbol_2 [[buffer(2)]]) {
-  (*(tint_symbol)).data.arr[(*(tint_symbol_1)).dynamic_idx] = 1;
-  (*(tint_symbol_2)).out = (*(tint_symbol)).data.arr[3];
+  (*(tint_symbol)).data[(*(tint_symbol_1)).dynamic_idx] = 1;
+  (*(tint_symbol_2)).out = (*(tint_symbol)).data[3];
   return;
 }
 
diff --git a/test/tint/bug/fxc/dyn_array_idx/write/workgroup.wgsl.expected.msl b/test/tint/bug/fxc/dyn_array_idx/write/workgroup.wgsl.expected.msl
index 2a33967..fa5f687 100644
--- a/test/tint/bug/fxc/dyn_array_idx/write/workgroup.wgsl.expected.msl
+++ b/test/tint/bug/fxc/dyn_array_idx/write/workgroup.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UBO {
   /* 0x0000 */ int dynamic_idx;
 };
 
-struct tint_array_wrapper {
-  int arr[64];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<int, 64> data;
 };
 
 struct Result {
@@ -20,11 +29,11 @@
 void f_inner(uint local_invocation_index, threadgroup S* const tint_symbol, const constant UBO* const tint_symbol_1, device Result* const tint_symbol_2) {
   for(uint idx = local_invocation_index; (idx < 64u); idx = (idx + 1u)) {
     uint const i = idx;
-    (*(tint_symbol)).data.arr[i] = 0;
+    (*(tint_symbol)).data[i] = 0;
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
-  (*(tint_symbol)).data.arr[(*(tint_symbol_1)).dynamic_idx] = 1;
-  (*(tint_symbol_2)).out = (*(tint_symbol)).data.arr[3];
+  (*(tint_symbol)).data[(*(tint_symbol_1)).dynamic_idx] = 1;
+  (*(tint_symbol_2)).out = (*(tint_symbol)).data[3];
 }
 
 kernel void f(const constant UBO* tint_symbol_4 [[buffer(0)]], device Result* tint_symbol_5 [[buffer(1)]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
diff --git a/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.msl b/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.msl
index de2ff47..6507f58 100644
--- a/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.msl
+++ b/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.msl
@@ -2,6 +2,18 @@
 
 using namespace metal;
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 template<typename T, int N, int M>
 inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
   return lhs * vec<T, N>(rhs);
@@ -16,26 +28,22 @@
   /* 0x0000 */ uint i;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ float3 arr[8];
-};
-
 struct Particle {
-  /* 0x0000 */ tint_array_wrapper position;
+  /* 0x0000 */ tint_array<float3, 8> position;
   /* 0x0080 */ float lifetime;
-  /* 0x0084 */ int8_t tint_pad[12];
+  /* 0x0084 */ tint_array<int8_t, 12> tint_pad;
   /* 0x0090 */ float4 color;
   /* 0x00a0 */ packed_float3 velocity;
-  /* 0x00ac */ int8_t tint_pad_1[4];
+  /* 0x00ac */ tint_array<int8_t, 4> tint_pad_1;
 };
 
 struct Particles {
-  /* 0x0000 */ Particle p[1];
+  /* 0x0000 */ tint_array<Particle, 1> p;
 };
 
 kernel void tint_symbol(const device Particles* tint_symbol_1 [[buffer(1)]], const constant Simulation* tint_symbol_2 [[buffer(0)]]) {
   Particle particle = (*(tint_symbol_1)).p[0];
-  particle.position.arr[(*(tint_symbol_2)).i] = particle.position.arr[(*(tint_symbol_2)).i];
+  particle.position[(*(tint_symbol_2)).i] = particle.position[(*(tint_symbol_2)).i];
   return;
 }
 
diff --git a/test/tint/bug/tint/1046.wgsl.expected.msl b/test/tint/bug/tint/1046.wgsl.expected.msl
index feb5d4d..c79bc0a 100644
--- a/test/tint/bug/tint/1046.wgsl.expected.msl
+++ b/test/tint/bug/tint/1046.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct PointLight {
   float4 position;
 };
 
 struct PointLights {
-  PointLight values[1];
+  tint_array<PointLight, 1> values;
 };
 
 struct Uniforms {
@@ -14,7 +27,7 @@
   /* 0x0040 */ float4x4 proj;
   /* 0x0080 */ uint numPointLights;
   /* 0x0084 */ uint color_source;
-  /* 0x0088 */ int8_t tint_pad[8];
+  /* 0x0088 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0090 */ float4 color;
 };
 
diff --git a/test/tint/bug/tint/1088.spvasm.expected.msl b/test/tint/bug/tint/1088.spvasm.expected.msl
index b2533c6..392fd22 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.msl
+++ b/test/tint/bug/tint/1088.spvasm.expected.msl
@@ -1,25 +1,30 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ float4x4 arr[2];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct strided_arr {
   /* 0x0000 */ float el;
-  /* 0x0004 */ int8_t tint_pad[12];
-};
-
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ strided_arr arr[4];
+  /* 0x0004 */ tint_array<int8_t, 12> tint_pad;
 };
 
 struct LeftOver {
   /* 0x0000 */ float4x4 worldViewProjection;
   /* 0x0040 */ float time;
-  /* 0x0044 */ int8_t tint_pad_1[12];
-  /* 0x0050 */ tint_array_wrapper test2;
-  /* 0x00d0 */ tint_array_wrapper_1 test;
+  /* 0x0044 */ tint_array<int8_t, 12> tint_pad_1;
+  /* 0x0050 */ tint_array<float4x4, 2> test2;
+  /* 0x00d0 */ tint_array<strided_arr, 4> test;
 };
 
 void main_1(thread float3* const tint_symbol_5, const constant LeftOver* const tint_symbol_6, thread float4* const tint_symbol_7, thread float2* const tint_symbol_8, thread float2* const tint_symbol_9) {
@@ -30,7 +35,7 @@
   float4 const x_21 = q;
   p = float3(x_21[0], x_21[1], x_21[2]);
   float const x_27 = p[0];
-  float const x_41 = (*(tint_symbol_6)).test.arr[0].el;
+  float const x_41 = (*(tint_symbol_6)).test[0].el;
   float const x_45 = (*(tint_symbol_5))[1];
   float const x_49 = (*(tint_symbol_6)).time;
   p[0] = (x_27 + sin(((x_41 * x_45) + x_49)));
diff --git a/test/tint/bug/tint/1113.wgsl.expected.msl b/test/tint/bug/tint/1113.wgsl.expected.msl
index 2c4dcc8..b62d4c5 100644
--- a/test/tint/bug/tint/1113.wgsl.expected.msl
+++ b/test/tint/bug/tint/1113.wgsl.expected.msl
@@ -12,15 +12,27 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint numTriangles;
   /* 0x0004 */ uint gridSize;
   /* 0x0008 */ uint pad1;
   /* 0x000c */ uint pad2;
   /* 0x0010 */ packed_float3 bbMin;
-  /* 0x001c */ int8_t tint_pad[4];
+  /* 0x001c */ tint_array<int8_t, 4> tint_pad;
   /* 0x0020 */ packed_float3 bbMax;
-  /* 0x002c */ int8_t tint_pad_1[4];
+  /* 0x002c */ tint_array<int8_t, 4> tint_pad_1;
 };
 
 struct Dbg {
@@ -39,23 +51,23 @@
 };
 
 struct F32s {
-  /* 0x0000 */ float values[1];
+  /* 0x0000 */ tint_array<float, 1> values;
 };
 
 struct U32s {
-  /* 0x0000 */ uint values[1];
+  /* 0x0000 */ tint_array<uint, 1> values;
 };
 
 struct I32s {
-  int values[1];
+  tint_array<int, 1> values;
 };
 
 struct AU32s {
-  /* 0x0000 */ atomic_uint values[1];
+  /* 0x0000 */ tint_array<atomic_uint, 1> values;
 };
 
 struct AI32s {
-  /* 0x0000 */ atomic_int values[1];
+  /* 0x0000 */ tint_array<atomic_int, 1> values;
 };
 
 float3 toVoxelPos(float3 position, const constant Uniforms* const tint_symbol_1) {
diff --git a/test/tint/bug/tint/1121.wgsl.expected.msl b/test/tint/bug/tint/1121.wgsl.expected.msl
index 4800aec..5e8c10f 100644
--- a/test/tint/bug/tint/1121.wgsl.expected.msl
+++ b/test/tint/bug/tint/1121.wgsl.expected.msl
@@ -12,6 +12,18 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct LightData {
   /* 0x0000 */ float4 position;
   /* 0x0010 */ packed_float3 color;
@@ -19,24 +31,16 @@
 };
 
 struct LightsBuffer {
-  /* 0x0000 */ LightData lights[1];
-};
-
-struct tint_array_wrapper {
-  /* 0x0000 */ uint arr[64];
+  /* 0x0000 */ tint_array<LightData, 1> lights;
 };
 
 struct TileLightIdData {
   /* 0x0000 */ atomic_uint count;
-  /* 0x0004 */ tint_array_wrapper lightId;
-};
-
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ TileLightIdData arr[4];
+  /* 0x0004 */ tint_array<uint, 64> lightId;
 };
 
 struct Tiles {
-  /* 0x0000 */ tint_array_wrapper_1 data;
+  /* 0x0000 */ tint_array<TileLightIdData, 4> data;
 };
 
 struct Config {
@@ -56,10 +60,6 @@
   /* 0x00a0 */ float4 fullScreenSize;
 };
 
-struct tint_array_wrapper_2 {
-  float4 arr[6];
-};
-
 void tint_symbol_inner(uint3 GlobalInvocationID, const constant Config* const tint_symbol_1, device LightsBuffer* const tint_symbol_2, const constant Uniforms* const tint_symbol_3, device Tiles* const tint_symbol_4) {
   uint index = GlobalInvocationID[0];
   if ((index >= (*(tint_symbol_1)).numLights)) {
@@ -78,9 +78,9 @@
   float lightRadius = (*(tint_symbol_2)).lights[index].radius;
   float4 boxMin = (lightPos - float4(float3(lightRadius), 0.0f));
   float4 boxMax = (lightPos + float4(float3(lightRadius), 0.0f));
-  tint_array_wrapper_2 frustumPlanes = {};
-  frustumPlanes.arr[4] = float4(0.0f, 0.0f, -1.0f, viewNear);
-  frustumPlanes.arr[5] = float4(0.0f, 0.0f, 1.0f, -(viewFar));
+  tint_array<float4, 6> frustumPlanes = {};
+  frustumPlanes[4] = float4(0.0f, 0.0f, -1.0f, viewNear);
+  frustumPlanes[5] = float4(0.0f, 0.0f, 1.0f, -(viewFar));
   int const TILE_SIZE = 16;
   int const TILE_COUNT_X = 2;
   int const TILE_COUNT_Y = 2;
@@ -91,41 +91,41 @@
       float2 ceilCoord = (((2.0f * float2(as_type<int2>((as_type<uint2>(tilePixel0Idx) + as_type<uint2>(int2(16)))))) / float4((*(tint_symbol_3)).fullScreenSize).xy) - float2(1.0f));
       float2 viewFloorCoord = float2((((-(viewNear) * floorCoord[0]) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * floorCoord[1]) - (M[2][1] * viewNear)) / M[1][1]));
       float2 viewCeilCoord = float2((((-(viewNear) * ceilCoord[0]) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * ceilCoord[1]) - (M[2][1] * viewNear)) / M[1][1]));
-      frustumPlanes.arr[0] = float4(1.0f, 0.0f, (-(viewFloorCoord[0]) / viewNear), 0.0f);
-      frustumPlanes.arr[1] = float4(-1.0f, 0.0f, (viewCeilCoord[0] / viewNear), 0.0f);
-      frustumPlanes.arr[2] = float4(0.0f, 1.0f, (-(viewFloorCoord[1]) / viewNear), 0.0f);
-      frustumPlanes.arr[3] = float4(0.0f, -1.0f, (viewCeilCoord[1] / viewNear), 0.0f);
+      frustumPlanes[0] = float4(1.0f, 0.0f, (-(viewFloorCoord[0]) / viewNear), 0.0f);
+      frustumPlanes[1] = float4(-1.0f, 0.0f, (viewCeilCoord[0] / viewNear), 0.0f);
+      frustumPlanes[2] = float4(0.0f, 1.0f, (-(viewFloorCoord[1]) / viewNear), 0.0f);
+      frustumPlanes[3] = float4(0.0f, -1.0f, (viewCeilCoord[1] / viewNear), 0.0f);
       float dp = 0.0f;
       for(uint i = 0u; (i < 6u); i = (i + 1u)) {
         float4 p = 0.0f;
-        if ((frustumPlanes.arr[i][0] > 0.0f)) {
+        if ((frustumPlanes[i][0] > 0.0f)) {
           p[0] = boxMax[0];
         } else {
           p[0] = boxMin[0];
         }
-        if ((frustumPlanes.arr[i][1] > 0.0f)) {
+        if ((frustumPlanes[i][1] > 0.0f)) {
           p[1] = boxMax[1];
         } else {
           p[1] = boxMin[1];
         }
-        if ((frustumPlanes.arr[i][2] > 0.0f)) {
+        if ((frustumPlanes[i][2] > 0.0f)) {
           p[2] = boxMax[2];
         } else {
           p[2] = boxMin[2];
         }
         p[3] = 1.0f;
-        dp = (dp + fmin(0.0f, dot(p, frustumPlanes.arr[i])));
+        dp = (dp + fmin(0.0f, dot(p, frustumPlanes[i])));
       }
       if ((dp >= 0.0f)) {
         uint tileId = uint(as_type<int>((as_type<uint>(x_1) + as_type<uint>(as_type<int>((as_type<uint>(y_1) * as_type<uint>(2)))))));
         if (((tileId < 0u) || (tileId >= (*(tint_symbol_1)).numTiles))) {
           continue;
         }
-        uint offset = atomic_fetch_add_explicit(&((*(tint_symbol_4)).data.arr[tileId].count), 1u, memory_order_relaxed);
+        uint offset = atomic_fetch_add_explicit(&((*(tint_symbol_4)).data[tileId].count), 1u, memory_order_relaxed);
         if ((offset >= (*(tint_symbol_1)).numTileLightSlot)) {
           continue;
         }
-        (*(tint_symbol_4)).data.arr[tileId].lightId.arr[offset] = GlobalInvocationID[0];
+        (*(tint_symbol_4)).data[tileId].lightId[offset] = GlobalInvocationID[0];
       }
     }
   }
diff --git a/test/tint/bug/tint/1321.wgsl.expected.msl b/test/tint/bug/tint/1321.wgsl.expected.msl
index 8c96d14..c67bb76 100644
--- a/test/tint/bug/tint/1321.wgsl.expected.msl
+++ b/test/tint/bug/tint/1321.wgsl.expected.msl
@@ -1,20 +1,29 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 int foo() {
   return 1;
 }
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
 fragment void tint_symbol() {
-  tint_array_wrapper arr = {.arr={}};
+  tint_array<float, 4> arr = tint_array<float, 4>{};
   int const tint_symbol_1 = foo();
   int const a_save = tint_symbol_1;
   for(; ; ) {
-    float const x = arr.arr[a_save];
+    float const x = arr[a_save];
     break;
   }
   return;
diff --git a/test/tint/bug/tint/1385.wgsl.expected.msl b/test/tint/bug/tint/1385.wgsl.expected.msl
index 838babd..c57afce 100644
--- a/test/tint/bug/tint/1385.wgsl.expected.msl
+++ b/test/tint/bug/tint/1385.wgsl.expected.msl
@@ -1,11 +1,24 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_symbol_3 {
-  /* 0x0000 */ int arr[1];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-int foo(const device int (*const tint_symbol_1)[1]) {
+struct tint_symbol_3 {
+  /* 0x0000 */ tint_array<int, 1> arr;
+};
+
+int foo(const device tint_array<int, 1>* const tint_symbol_1) {
   return (*(tint_symbol_1))[0];
 }
 
diff --git a/test/tint/bug/tint/1520.spvasm.expected.msl b/test/tint/bug/tint/1520.spvasm.expected.msl
index 909a052..a556dee 100644
--- a/test/tint/bug/tint/1520.spvasm.expected.msl
+++ b/test/tint/bug/tint/1520.spvasm.expected.msl
@@ -1,10 +1,23 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct UniformBuffer {
-  /* 0x0000 */ int8_t tint_pad[16];
+  /* 0x0000 */ tint_array<int8_t, 16> tint_pad;
   /* 0x0010 */ float unknownInput_S1_c0;
-  /* 0x0014 */ int8_t tint_pad_1[12];
+  /* 0x0014 */ tint_array<int8_t, 12> tint_pad_1;
   /* 0x0020 */ float4 ucolorRed_S1_c0;
   /* 0x0030 */ float4 ucolorGreen_S1_c0;
   /* 0x0040 */ float3x3 umatrix_S1;
diff --git a/test/tint/bug/tint/221.wgsl.expected.msl b/test/tint/bug/tint/221.wgsl.expected.msl
index 880fc07..ad7d150 100644
--- a/test/tint/bug/tint/221.wgsl.expected.msl
+++ b/test/tint/bug/tint/221.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ uint arr[50];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct Buf {
   /* 0x0000 */ uint count;
-  /* 0x0004 */ tint_array_wrapper data;
+  /* 0x0004 */ tint_array<uint, 50> data;
 };
 
 kernel void tint_symbol(device Buf* tint_symbol_1 [[buffer(0)]]) {
@@ -19,14 +28,14 @@
     uint const p_save = i;
     if (((i % 2u) == 0u)) {
       {
-        (*(tint_symbol_1)).data.arr[p_save] = ((*(tint_symbol_1)).data.arr[p_save] * 2u);
+        (*(tint_symbol_1)).data[p_save] = ((*(tint_symbol_1)).data[p_save] * 2u);
         i = (i + 1u);
       }
       continue;
     }
-    (*(tint_symbol_1)).data.arr[p_save] = 0u;
+    (*(tint_symbol_1)).data[p_save] = 0u;
     {
-      (*(tint_symbol_1)).data.arr[p_save] = ((*(tint_symbol_1)).data.arr[p_save] * 2u);
+      (*(tint_symbol_1)).data[p_save] = ((*(tint_symbol_1)).data[p_save] * 2u);
       i = (i + 1u);
     }
   }
diff --git a/test/tint/bug/tint/294.wgsl.expected.msl b/test/tint/bug/tint/294.wgsl.expected.msl
index 09c1cf5..77c8cea 100644
--- a/test/tint/bug/tint/294.wgsl.expected.msl
+++ b/test/tint/bug/tint/294.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Light {
   float3 position;
   float3 colour;
 };
 
 struct Lights {
-  Light light[1];
+  tint_array<Light, 1> light;
 };
 
diff --git a/test/tint/bug/tint/403.wgsl.expected.msl b/test/tint/bug/tint/403.wgsl.expected.msl
index 94e0fbe..10c2d04 100644
--- a/test/tint/bug/tint/403.wgsl.expected.msl
+++ b/test/tint/bug/tint/403.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct vertexUniformBuffer1 {
   /* 0x0000 */ float2x2 transform1;
 };
@@ -13,18 +26,14 @@
   float4 value [[position]];
 };
 
-struct tint_array_wrapper {
-  float2 arr[3];
-};
-
 float4 tint_symbol_inner(uint gl_VertexIndex, const constant vertexUniformBuffer1* const tint_symbol_3, const constant vertexUniformBuffer2* const tint_symbol_4) {
-  tint_array_wrapper indexable = {};
+  tint_array<float2, 3> indexable = {};
   float2x2 const x_23 = (*(tint_symbol_3)).transform1;
   float2x2 const x_28 = (*(tint_symbol_4)).transform2;
   uint const x_46 = gl_VertexIndex;
-  tint_array_wrapper const tint_symbol_2 = {.arr={float2(-1.0f, 1.0f), float2(1.0f), float2(-1.0f)}};
+  tint_array<float2, 3> const tint_symbol_2 = tint_array<float2, 3>{float2(-1.0f, 1.0f), float2(1.0f), float2(-1.0f)};
   indexable = tint_symbol_2;
-  float2 const x_51 = indexable.arr[x_46];
+  float2 const x_51 = indexable[x_46];
   float2 const x_52 = (float2x2((x_23[0u] + x_28[0u]), (x_23[1u] + x_28[1u])) * x_51);
   return float4(x_52[0], x_52[1], 0.0f, 1.0f);
 }
diff --git a/test/tint/bug/tint/534.wgsl.expected.msl b/test/tint/bug/tint/534.wgsl.expected.msl
index a766b37..2323162 100644
--- a/test/tint/bug/tint/534.wgsl.expected.msl
+++ b/test/tint/bug/tint/534.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint dstTextureFlipY;
   /* 0x0004 */ uint isFloat16;
@@ -9,7 +22,7 @@
 };
 
 struct OutputBuf {
-  /* 0x0000 */ uint result[1];
+  /* 0x0000 */ tint_array<uint, 1> result;
 };
 
 uint ConvertToFp16FloatValue(float fp32) {
diff --git a/test/tint/bug/tint/744.wgsl.expected.msl b/test/tint/bug/tint/744.wgsl.expected.msl
index c4dc5b4..7c01635 100644
--- a/test/tint/bug/tint/744.wgsl.expected.msl
+++ b/test/tint/bug/tint/744.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint2 aShape;
   /* 0x0008 */ uint2 bShape;
@@ -8,7 +21,7 @@
 };
 
 struct Matrix {
-  /* 0x0000 */ uint numbers[1];
+  /* 0x0000 */ tint_array<uint, 1> numbers;
 };
 
 void tint_symbol_inner(uint3 global_id, const constant Uniforms* const tint_symbol_1, const device Matrix* const tint_symbol_2, const device Matrix* const tint_symbol_3, device Matrix* const tint_symbol_4) {
diff --git a/test/tint/bug/tint/749.spvasm.expected.msl b/test/tint/bug/tint/749.spvasm.expected.msl
index 89108e5..f14f399 100644
--- a/test/tint/bug/tint/749.spvasm.expected.msl
+++ b/test/tint/bug/tint/749.spvasm.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[10];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct QuicksortObject {
-  tint_array_wrapper numbers;
+  tint_array<int, 10> numbers;
 };
 
 struct buf0 {
@@ -31,10 +40,10 @@
   temp = 0;
   temp = x_935;
   int const x_30_save = x_28;
-  int const x_936 = (*(tint_symbol_81)).numbers.arr[x_30_save];
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = x_936;
-  int const x_31 = (*(tint_symbol_81)).numbers.arr[x_30_save];
+  int const x_936 = (*(tint_symbol_81)).numbers[x_30_save];
+  (*(tint_symbol_81)).numbers[x_30_save] = 0;
+  (*(tint_symbol_81)).numbers[x_30_save] = x_936;
+  int const x_31 = (*(tint_symbol_81)).numbers[x_30_save];
   int const x_937 = temp;
   temp = 0;
   temp = x_937;
@@ -47,30 +56,30 @@
   *(i) = 0;
   *(i) = x_939;
   int const x_32 = *(i);
-  int const x_940 = (*(tint_symbol_81)).numbers.arr[x_30_save];
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = x_940;
+  int const x_940 = (*(tint_symbol_81)).numbers[x_30_save];
+  (*(tint_symbol_81)).numbers[x_30_save] = 0;
+  (*(tint_symbol_81)).numbers[x_30_save] = x_940;
   int const x_33 = *(j);
   int const x_941 = *(i);
   *(i) = 0;
   *(i) = x_941;
   float3 const x_526 = float3(x_525[0], x_525[2], x_525[2]);
-  int const x_942 = (*(tint_symbol_81)).numbers.arr[x_30_save];
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_30_save] = x_942;
+  int const x_942 = (*(tint_symbol_81)).numbers[x_30_save];
+  (*(tint_symbol_81)).numbers[x_30_save] = 0;
+  (*(tint_symbol_81)).numbers[x_30_save] = x_942;
   int const x_34_save = x_33;
-  int const x_35 = (*(tint_symbol_81)).numbers.arr[x_34_save];
+  int const x_35 = (*(tint_symbol_81)).numbers[x_34_save];
   QuicksortObject const x_943 = *(tint_symbol_81);
-  tint_array_wrapper const tint_symbol_2 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_2 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_3 = {.numbers=tint_symbol_2};
   *(tint_symbol_81) = tint_symbol_3;
   *(tint_symbol_81) = x_943;
   float2 const x_527 = float2(x_526[0], x_526[0]);
   int const x_36_save = x_32;
   float3 const x_528 = float3(x_524[0], x_524[2], x_524[0]);
-  (*(tint_symbol_81)).numbers.arr[x_36_save] = x_35;
+  (*(tint_symbol_81)).numbers[x_36_save] = x_35;
   QuicksortObject const x_944 = *(tint_symbol_81);
-  tint_array_wrapper const tint_symbol_4 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_4 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_5 = {.numbers=tint_symbol_4};
   *(tint_symbol_81) = tint_symbol_5;
   *(tint_symbol_81) = x_944;
@@ -83,27 +92,27 @@
   temp = 0;
   temp = x_946;
   float2 const x_530 = float2(x_529[2], x_529[1]);
-  int const x_947 = (*(tint_symbol_81)).numbers.arr[x_34_save];
-  (*(tint_symbol_81)).numbers.arr[x_34_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_34_save] = x_947;
+  int const x_947 = (*(tint_symbol_81)).numbers[x_34_save];
+  (*(tint_symbol_81)).numbers[x_34_save] = 0;
+  (*(tint_symbol_81)).numbers[x_34_save] = x_947;
   int const x_38 = temp;
   int const x_948 = *(j);
   *(j) = 0;
   *(j) = x_948;
   float3 const x_531 = float3(x_527[0], x_526[1], x_526[0]);
-  int const x_949 = (*(tint_symbol_81)).numbers.arr[x_36_save];
-  (*(tint_symbol_81)).numbers.arr[x_36_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_36_save] = x_949;
+  int const x_949 = (*(tint_symbol_81)).numbers[x_36_save];
+  (*(tint_symbol_81)).numbers[x_36_save] = 0;
+  (*(tint_symbol_81)).numbers[x_36_save] = x_949;
   QuicksortObject const x_950 = *(tint_symbol_81);
-  tint_array_wrapper const tint_symbol_6 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_6 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_7 = {.numbers=tint_symbol_6};
   *(tint_symbol_81) = tint_symbol_7;
   *(tint_symbol_81) = x_950;
   float3 const x_532 = float3(x_528[0], x_528[1], x_528[0]);
-  int const x_951 = (*(tint_symbol_81)).numbers.arr[x_34_save];
-  (*(tint_symbol_81)).numbers.arr[x_34_save] = 0;
-  (*(tint_symbol_81)).numbers.arr[x_34_save] = x_951;
-  (*(tint_symbol_81)).numbers.arr[x_37] = x_38;
+  int const x_951 = (*(tint_symbol_81)).numbers[x_34_save];
+  (*(tint_symbol_81)).numbers[x_34_save] = 0;
+  (*(tint_symbol_81)).numbers[x_34_save] = x_951;
+  (*(tint_symbol_81)).numbers[x_37] = x_38;
   return;
 }
 
@@ -125,10 +134,10 @@
   *(l) = 0;
   *(l) = x_953;
   int const x_42_save = x_41;
-  int const x_954 = (*(tint_symbol_82)).numbers.arr[x_42_save];
-  (*(tint_symbol_82)).numbers.arr[x_42_save] = 0;
-  (*(tint_symbol_82)).numbers.arr[x_42_save] = x_954;
-  int const x_43 = (*(tint_symbol_82)).numbers.arr[x_42_save];
+  int const x_954 = (*(tint_symbol_82)).numbers[x_42_save];
+  (*(tint_symbol_82)).numbers[x_42_save] = 0;
+  (*(tint_symbol_82)).numbers[x_42_save] = x_954;
+  int const x_43 = (*(tint_symbol_82)).numbers[x_42_save];
   int const x_955 = param_3;
   param_3 = 0;
   param_3 = x_955;
@@ -153,7 +162,7 @@
   float3 const x_536 = float3(x_534[0], x_534[2], x_535[0]);
   j_1 = 10;
   QuicksortObject const x_960 = *(tint_symbol_82);
-  tint_array_wrapper const tint_symbol_8 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_8 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_9 = {.numbers=tint_symbol_8};
   *(tint_symbol_82) = tint_symbol_9;
   *(tint_symbol_82) = x_960;
@@ -170,7 +179,7 @@
     pivot = x_963;
     x_537 = float2(float3(1.0f, 2.0f, 3.0f)[1], float3(1.0f, 2.0f, 3.0f)[2]);
     QuicksortObject const x_964 = *(tint_symbol_82);
-    tint_array_wrapper const tint_symbol_10 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_10 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_11 = {.numbers=tint_symbol_10};
     *(tint_symbol_82) = tint_symbol_11;
     *(tint_symbol_82) = x_964;
@@ -193,9 +202,9 @@
       break;
     }
     int const x_60 = j_1;
-    int const x_969 = (*(tint_symbol_82)).numbers.arr[x_42_save];
-    (*(tint_symbol_82)).numbers.arr[x_42_save] = 0;
-    (*(tint_symbol_82)).numbers.arr[x_42_save] = x_969;
+    int const x_969 = (*(tint_symbol_82)).numbers[x_42_save];
+    (*(tint_symbol_82)).numbers[x_42_save] = 0;
+    (*(tint_symbol_82)).numbers[x_42_save] = x_969;
     int const x_61_save = x_60;
     int const x_970 = *(h);
     *(h) = 0;
@@ -204,9 +213,9 @@
     int const x_971 = param_1;
     param_1 = 0;
     param_1 = x_971;
-    int const x_62 = (*(tint_symbol_82)).numbers.arr[x_61_save];
+    int const x_62 = (*(tint_symbol_82)).numbers[x_61_save];
     QuicksortObject const x_972 = *(tint_symbol_82);
-    tint_array_wrapper const tint_symbol_12 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_12 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_13 = {.numbers=tint_symbol_12};
     *(tint_symbol_82) = tint_symbol_13;
     *(tint_symbol_82) = x_972;
@@ -267,7 +276,7 @@
       param_1 = x_985;
     }
     QuicksortObject const x_986 = *(tint_symbol_82);
-    tint_array_wrapper const tint_symbol_14 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_14 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_15 = {.numbers=tint_symbol_14};
     *(tint_symbol_82) = tint_symbol_15;
     *(tint_symbol_82) = x_986;
@@ -280,9 +289,9 @@
       *(h) = 0;
       *(h) = x_988;
       float3 const x_547 = float3(x_539[0], x_541[2], x_541[2]);
-      int const x_989 = (*(tint_symbol_82)).numbers.arr[x_61_save];
-      (*(tint_symbol_82)).numbers.arr[x_61_save] = 0;
-      (*(tint_symbol_82)).numbers.arr[x_61_save] = x_989;
+      int const x_989 = (*(tint_symbol_82)).numbers[x_61_save];
+      (*(tint_symbol_82)).numbers[x_61_save] = 0;
+      (*(tint_symbol_82)).numbers[x_61_save] = x_989;
       int const x_990 = param;
       param = 0;
       param = x_990;
@@ -291,18 +300,18 @@
       param_1 = 0;
       param_1 = x_991;
       float3 const x_548 = float3(x_541[1], x_541[2], x_541[0]);
-      int const x_992 = (*(tint_symbol_82)).numbers.arr[x_61_save];
-      (*(tint_symbol_82)).numbers.arr[x_61_save] = 0;
-      (*(tint_symbol_82)).numbers.arr[x_61_save] = x_992;
+      int const x_992 = (*(tint_symbol_82)).numbers[x_61_save];
+      (*(tint_symbol_82)).numbers[x_61_save] = 0;
+      (*(tint_symbol_82)).numbers[x_61_save] = x_992;
     }
   }
   int const x_76 = i_1;
-  int const x_993 = (*(tint_symbol_82)).numbers.arr[x_42_save];
-  (*(tint_symbol_82)).numbers.arr[x_42_save] = 0;
-  (*(tint_symbol_82)).numbers.arr[x_42_save] = x_993;
+  int const x_993 = (*(tint_symbol_82)).numbers[x_42_save];
+  (*(tint_symbol_82)).numbers[x_42_save] = 0;
+  (*(tint_symbol_82)).numbers[x_42_save] = x_993;
   float2 const x_549 = float2(x_534[0], x_534[1]);
   QuicksortObject const x_994 = *(tint_symbol_82);
-  tint_array_wrapper const tint_symbol_16 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_16 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_17 = {.numbers=tint_symbol_16};
   *(tint_symbol_82) = tint_symbol_17;
   *(tint_symbol_82) = x_994;
@@ -364,15 +373,15 @@
   int p = 0;
   int l_1 = 0;
   int top = 0;
-  tint_array_wrapper stack = {};
+  tint_array<int, 10> stack = {};
   int param_5 = 0;
   l_1 = 0;
   int const x_1007 = param_5;
   param_5 = 0;
   param_5 = x_1007;
   h_1 = 9;
-  tint_array_wrapper const x_1008 = stack;
-  tint_array_wrapper const tint_symbol_18 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const x_1008 = stack;
+  tint_array<int, 10> const tint_symbol_18 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   stack = tint_symbol_18;
   stack = x_1008;
   float2 const x_556 = float2(float3(1.0f, 2.0f, 3.0f)[1], float3(1.0f, 2.0f, 3.0f)[1]);
@@ -406,21 +415,21 @@
   param_4 = x_1015;
   int const x_95 = l_1;
   QuicksortObject const x_1016 = *(tint_symbol_83);
-  tint_array_wrapper const tint_symbol_19 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_19 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_20 = {.numbers=tint_symbol_19};
   *(tint_symbol_83) = tint_symbol_20;
   *(tint_symbol_83) = x_1016;
   float3 const x_560 = float3(x_559[1], x_559[0], x_557[0]);
   int const x_96_save = x_94;
-  tint_array_wrapper const x_1017 = stack;
-  tint_array_wrapper const tint_symbol_21 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const x_1017 = stack;
+  tint_array<int, 10> const tint_symbol_21 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   stack = tint_symbol_21;
   stack = x_1017;
   float3 const x_561 = float3(x_556[1], x_556[1], x_556[1]);
   int const x_1018 = l_1;
   l_1 = 0;
   l_1 = 0;
-  stack.arr[x_96_save] = x_95;
+  stack[x_96_save] = x_95;
   int const x_1019 = param_5;
   param_5 = 0;
   param_5 = x_1019;
@@ -429,13 +438,13 @@
   param_4 = 0;
   param_4 = x_1020;
   float3 const x_562 = float3(float3(1.0f, 2.0f, 3.0f)[2], x_558[1], float3(1.0f, 2.0f, 3.0f)[1]);
-  int const x_1021 = stack.arr[x_96_save];
-  stack.arr[x_96_save] = 0;
-  stack.arr[x_96_save] = x_1021;
+  int const x_1021 = stack[x_96_save];
+  stack[x_96_save] = 0;
+  stack[x_96_save] = x_1021;
   int const x_98 = as_type<int>((as_type<uint>(x_97) + as_type<uint>(1)));
-  int const x_1022 = stack.arr[x_96_save];
-  stack.arr[x_96_save] = 0;
-  stack.arr[x_96_save] = x_1022;
+  int const x_1022 = stack[x_96_save];
+  stack[x_96_save] = 0;
+  stack[x_96_save] = x_1022;
   float3 const x_563 = float3(x_559[0], x_559[2], x_556[1]);
   top = x_98;
   int const x_1023 = param_4;
@@ -457,19 +466,19 @@
   int const x_1027 = p;
   p = 0;
   p = x_1027;
-  stack.arr[x_100_save] = x_99;
+  stack[x_100_save] = x_99;
   while (true) {
     float3 const x_566 = float3(x_563[0], x_563[0], x_563[0]);
     int const x_1028 = h_1;
     h_1 = 0;
     h_1 = x_1028;
-    tint_array_wrapper const x_1029 = stack;
-    tint_array_wrapper const tint_symbol_22 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const x_1029 = stack;
+    tint_array<int, 10> const tint_symbol_22 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     stack = tint_symbol_22;
     stack = x_1029;
     int const x_106 = top;
-    tint_array_wrapper const x_1030 = stack;
-    tint_array_wrapper const tint_symbol_23 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const x_1030 = stack;
+    tint_array<int, 10> const tint_symbol_23 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     stack = tint_symbol_23;
     stack = x_1030;
     float2 const x_567 = float2(x_558[0], x_564[2]);
@@ -481,7 +490,7 @@
       break;
     }
     QuicksortObject const x_1032 = *(tint_symbol_83);
-    tint_array_wrapper const tint_symbol_24 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_24 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_25 = {.numbers=tint_symbol_24};
     *(tint_symbol_83) = tint_symbol_25;
     *(tint_symbol_83) = x_1032;
@@ -503,12 +512,12 @@
     p = 0;
     p = x_1036;
     int const x_110_save = x_108;
-    int const x_1037 = stack.arr[x_96_save];
-    stack.arr[x_96_save] = 0;
-    stack.arr[x_96_save] = x_1037;
-    int const x_111 = stack.arr[x_110_save];
-    tint_array_wrapper const x_1038 = stack;
-    tint_array_wrapper const tint_symbol_26 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    int const x_1037 = stack[x_96_save];
+    stack[x_96_save] = 0;
+    stack[x_96_save] = x_1037;
+    int const x_111 = stack[x_110_save];
+    tint_array<int, 10> const x_1038 = stack;
+    tint_array<int, 10> const tint_symbol_26 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     stack = tint_symbol_26;
     stack = x_1038;
     float3 const x_571 = float3(x_559[1], x_559[0], x_564[1]);
@@ -516,8 +525,8 @@
     l_1 = 0;
     l_1 = x_1039;
     h_1 = x_111;
-    tint_array_wrapper const x_1040 = stack;
-    tint_array_wrapper const tint_symbol_27 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const x_1040 = stack;
+    tint_array<int, 10> const tint_symbol_27 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     stack = tint_symbol_27;
     stack = x_1040;
     float2 const x_572 = float2(x_562[1], x_561[1]);
@@ -528,9 +537,9 @@
     int const x_1042 = param_4;
     param_4 = 0;
     param_4 = x_1042;
-    int const x_1043 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1043;
+    int const x_1043 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1043;
     float2 const x_573 = float2(float3(1.0f, 2.0f, 3.0f)[1], float3(1.0f, 2.0f, 3.0f)[2]);
     top = as_type<int>((as_type<uint>(x_112) - as_type<uint>(1)));
     int const x_1044 = param_5;
@@ -542,10 +551,10 @@
     h_1 = x_1045;
     int const x_114_save = x_112;
     float2 const x_575 = float2(x_564[1], x_564[2]);
-    int const x_1046 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1046;
-    int const x_115 = stack.arr[x_114_save];
+    int const x_1046 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1046;
+    int const x_115 = stack[x_114_save];
     int const x_1047 = p;
     p = 0;
     p = x_1047;
@@ -559,16 +568,16 @@
     top = x_1049;
     int const x_118 = l_1;
     param_4 = x_118;
-    int const x_1050 = stack.arr[x_110_save];
-    stack.arr[x_110_save] = 0;
-    stack.arr[x_110_save] = x_1050;
+    int const x_1050 = stack[x_110_save];
+    stack[x_110_save] = 0;
+    stack[x_110_save] = x_1050;
     float2 const x_577 = float2(x_569[1], x_569[2]);
     int const x_120 = h_1;
     float2 const x_578 = float2(x_558[0], float3(1.0f, 2.0f, 3.0f)[1]);
     param_5 = x_120;
-    int const x_1051 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1051;
+    int const x_1051 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1051;
     int const x_121 = performPartition_i1_i1_(&(param_4), &(param_5), tint_symbol_83);
     float2 const x_579 = float2(x_567[0], x_568[0]);
     int const x_1052 = param_5;
@@ -590,140 +599,140 @@
     h_1 = 0;
     h_1 = x_1056;
     int const x_124 = l_1;
-    int const x_1057 = stack.arr[x_110_save];
-    stack.arr[x_110_save] = 0;
-    stack.arr[x_110_save] = x_1057;
+    int const x_1057 = stack[x_110_save];
+    stack[x_110_save] = 0;
+    stack[x_110_save] = x_1057;
     int const x_1058 = h_1;
     h_1 = 0;
     h_1 = x_1058;
     float2 const x_582 = float2(x_567[1], x_573[0]);
-    int const x_1059 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1059;
+    int const x_1059 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1059;
     if ((as_type<int>((as_type<uint>(x_122) - as_type<uint>(as_type<int>(1u)))) > x_124)) {
       int const x_1060 = param_4;
       param_4 = 0;
       param_4 = x_1060;
       int const x_128 = top;
       float2 const x_583 = float2(x_571[1], x_556[1]);
-      int const x_1061 = stack.arr[x_100_save];
-      stack.arr[x_100_save] = 0;
-      stack.arr[x_100_save] = x_1061;
-      tint_array_wrapper const x_1062 = stack;
-      tint_array_wrapper const tint_symbol_28 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+      int const x_1061 = stack[x_100_save];
+      stack[x_100_save] = 0;
+      stack[x_100_save] = x_1061;
+      tint_array<int, 10> const x_1062 = stack;
+      tint_array<int, 10> const tint_symbol_28 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       stack = tint_symbol_28;
       stack = x_1062;
       float2 const x_584 = float2(x_569[2], x_569[1]);
       float3 const x_585 = float3(x_580[1], x_577[0], x_577[0]);
       int const x_130 = l_1;
-      int const x_1063 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1063;
+      int const x_1063 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1063;
       float2 const x_586 = float2(x_564[0], x_585[0]);
       int const x_1064 = param_5;
       param_5 = 0;
       param_5 = x_1064;
       int const x_131_save = as_type<int>((as_type<uint>(1) + as_type<uint>(x_128)));
-      int const x_1065 = stack.arr[x_110_save];
-      stack.arr[x_110_save] = 0;
-      stack.arr[x_110_save] = x_1065;
+      int const x_1065 = stack[x_110_save];
+      stack[x_110_save] = 0;
+      stack[x_110_save] = x_1065;
       float3 const x_587 = float3(x_566[1], x_566[1], x_563[0]);
       int const x_1066 = param_5;
       param_5 = 0;
       param_5 = x_1066;
-      stack.arr[x_131_save] = x_130;
+      stack[x_131_save] = x_130;
       int const x_132 = top;
-      int const x_1067 = stack.arr[x_100_save];
-      stack.arr[x_100_save] = 0;
-      stack.arr[x_100_save] = x_1067;
+      int const x_1067 = stack[x_100_save];
+      stack[x_100_save] = 0;
+      stack[x_100_save] = x_1067;
       float2 const x_588 = float2(x_575[1], x_575[0]);
-      int const x_1068 = stack.arr[x_131_save];
-      stack.arr[x_131_save] = 0;
-      stack.arr[x_131_save] = x_1068;
+      int const x_1068 = stack[x_131_save];
+      stack[x_131_save] = 0;
+      stack[x_131_save] = x_1068;
       int const x_133 = as_type<int>((1u + as_type<uint>(x_132)));
-      int const x_1069 = stack.arr[x_100_save];
-      stack.arr[x_100_save] = 0;
-      stack.arr[x_100_save] = x_1069;
+      int const x_1069 = stack[x_100_save];
+      stack[x_100_save] = 0;
+      stack[x_100_save] = x_1069;
       float3 const x_589 = float3(x_576[2], x_588[1], x_576[2]);
       int const x_1070 = h_1;
       h_1 = 0;
       h_1 = x_1070;
       top = x_133;
-      tint_array_wrapper const x_1071 = stack;
-      tint_array_wrapper const tint_symbol_29 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+      tint_array<int, 10> const x_1071 = stack;
+      tint_array<int, 10> const tint_symbol_29 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       stack = tint_symbol_29;
       stack = x_1071;
       int const x_134 = p;
       float2 const x_590 = float2(x_576[0], x_573[1]);
-      int const x_1072 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1072;
+      int const x_1072 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1072;
       int const x_136_save = x_133;
-      int const x_1073 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1073;
-      stack.arr[x_136_save] = as_type<int>((as_type<uint>(x_134) - as_type<uint>(as_type<int>(1u))));
-      int const x_1074 = stack.arr[x_96_save];
-      stack.arr[x_96_save] = 0;
-      stack.arr[x_96_save] = x_1074;
+      int const x_1073 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1073;
+      stack[x_136_save] = as_type<int>((as_type<uint>(x_134) - as_type<uint>(as_type<int>(1u))));
+      int const x_1074 = stack[x_96_save];
+      stack[x_96_save] = 0;
+      stack[x_96_save] = x_1074;
       float2 const x_591 = float2(x_569[2], x_569[1]);
-      int const x_1075 = stack.arr[x_136_save];
-      stack.arr[x_136_save] = 0;
-      stack.arr[x_136_save] = x_1075;
+      int const x_1075 = stack[x_136_save];
+      stack[x_136_save] = 0;
+      stack[x_136_save] = x_1075;
     }
-    int const x_1076 = stack.arr[x_96_save];
-    stack.arr[x_96_save] = 0;
-    stack.arr[x_96_save] = x_1076;
+    int const x_1076 = stack[x_96_save];
+    stack[x_96_save] = 0;
+    stack[x_96_save] = x_1076;
     float2 const x_592 = float2(float3(1.0f, 2.0f, 3.0f)[0], float3(1.0f, 2.0f, 3.0f)[1]);
     QuicksortObject const x_1077 = *(tint_symbol_83);
-    tint_array_wrapper const tint_symbol_30 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_30 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_31 = {.numbers=tint_symbol_30};
     *(tint_symbol_83) = tint_symbol_31;
     *(tint_symbol_83) = x_1077;
     int const x_137 = p;
-    int const x_1078 = stack.arr[x_114_save];
-    stack.arr[x_114_save] = 0;
-    stack.arr[x_114_save] = x_1078;
+    int const x_1078 = stack[x_114_save];
+    stack[x_114_save] = 0;
+    stack[x_114_save] = x_1078;
     float3 const x_593 = float3(x_571[2], x_556[0], x_556[1]);
     int const x_1079 = p;
     p = 0;
     p = x_1079;
     float3 const x_594 = float3(x_563[2], x_563[0], x_575[0]);
-    int const x_1080 = stack.arr[x_114_save];
-    stack.arr[x_114_save] = 0;
-    stack.arr[x_114_save] = x_1080;
+    int const x_1080 = stack[x_114_save];
+    stack[x_114_save] = 0;
+    stack[x_114_save] = x_1080;
     int const x_139 = h_1;
     int const x_1081 = top;
     top = 0;
     top = x_1081;
     float3 const x_595 = float3(x_560[2], x_568[0], x_560[0]);
-    int const x_1082 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1082;
+    int const x_1082 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1082;
     int const x_1083 = p;
     p = 0;
     p = x_1083;
     if ((as_type<int>((1u + as_type<uint>(x_137))) < x_139)) {
-      int const x_1084 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1084;
+      int const x_1084 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1084;
       float2 const x_596 = float2(x_592[1], x_582[0]);
       int const x_1085 = l_1;
       l_1 = 0;
       l_1 = x_1085;
       int const x_143 = top;
-      int const x_1086 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1086;
+      int const x_1086 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1086;
       float3 const x_597 = float3(x_562[1], x_560[1], x_560[1]);
       int const x_144 = as_type<int>((as_type<uint>(x_143) + as_type<uint>(1)));
       int const x_1087 = param_5;
       param_5 = 0;
       param_5 = x_1087;
       top = x_144;
-      int const x_1088 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1088;
+      int const x_1088 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1088;
       int const x_145 = p;
       int const x_1089 = param_5;
       param_5 = 0;
@@ -733,62 +742,62 @@
       p = 0;
       p = x_1090;
       float3 const x_600 = float3(x_556[0], x_580[0], x_580[0]);
-      int const x_1091 = stack.arr[x_100_save];
-      stack.arr[x_100_save] = 0;
-      stack.arr[x_100_save] = x_1091;
+      int const x_1091 = stack[x_100_save];
+      stack[x_100_save] = 0;
+      stack[x_100_save] = x_1091;
       int const x_147_save = x_144;
-      int const x_1092 = stack.arr[x_110_save];
-      stack.arr[x_110_save] = 0;
-      stack.arr[x_110_save] = x_1092;
+      int const x_1092 = stack[x_110_save];
+      stack[x_110_save] = 0;
+      stack[x_110_save] = x_1092;
       float2 const x_601 = float2(x_563[0], x_563[1]);
-      stack.arr[x_147_save] = as_type<int>((1u + as_type<uint>(x_145)));
-      tint_array_wrapper const x_1093 = stack;
-      tint_array_wrapper const tint_symbol_32 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+      stack[x_147_save] = as_type<int>((1u + as_type<uint>(x_145)));
+      tint_array<int, 10> const x_1093 = stack;
+      tint_array<int, 10> const tint_symbol_32 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       stack = tint_symbol_32;
       stack = x_1093;
       int const x_148 = top;
-      int const x_1094 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1094;
+      int const x_1094 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1094;
       float2 const x_602 = float2(x_565[1], x_599[1]);
-      tint_array_wrapper const x_1095 = stack;
-      tint_array_wrapper const tint_symbol_33 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+      tint_array<int, 10> const x_1095 = stack;
+      tint_array<int, 10> const tint_symbol_33 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       stack = tint_symbol_33;
       stack = x_1095;
       int const x_149 = as_type<int>((as_type<uint>(x_148) + as_type<uint>(as_type<int>(1u))));
-      int const x_1096 = stack.arr[x_147_save];
-      stack.arr[x_147_save] = 0;
-      stack.arr[x_147_save] = x_1096;
+      int const x_1096 = stack[x_147_save];
+      stack[x_147_save] = 0;
+      stack[x_147_save] = x_1096;
       top = x_149;
       int const x_1097 = param_4;
       param_4 = 0;
       param_4 = x_1097;
       int const x_150 = h_1;
-      int const x_1098 = stack.arr[x_100_save];
-      stack.arr[x_100_save] = 0;
-      stack.arr[x_100_save] = x_1098;
-      int const x_1099 = stack.arr[x_96_save];
-      stack.arr[x_96_save] = 0;
-      stack.arr[x_96_save] = x_1099;
-      stack.arr[x_149] = x_150;
-      int const x_1100 = stack.arr[x_114_save];
-      stack.arr[x_114_save] = 0;
-      stack.arr[x_114_save] = x_1100;
+      int const x_1098 = stack[x_100_save];
+      stack[x_100_save] = 0;
+      stack[x_100_save] = x_1098;
+      int const x_1099 = stack[x_96_save];
+      stack[x_96_save] = 0;
+      stack[x_96_save] = x_1099;
+      stack[x_149] = x_150;
+      int const x_1100 = stack[x_114_save];
+      stack[x_114_save] = 0;
+      stack[x_114_save] = x_1100;
       float3 const x_603 = float3(x_568[1], x_564[0], x_564[0]);
       int const x_1101 = l_1;
       l_1 = 0;
       l_1 = x_1101;
     }
-    int const x_1102 = stack.arr[x_100_save];
-    stack.arr[x_100_save] = 0;
-    stack.arr[x_100_save] = x_1102;
+    int const x_1102 = stack[x_100_save];
+    stack[x_100_save] = 0;
+    stack[x_100_save] = x_1102;
     {
       int const x_1103 = l_1;
       l_1 = 0;
       l_1 = x_1103;
       float2 const x_604 = float2(x_563[2], x_564[0]);
       QuicksortObject const x_1104 = *(tint_symbol_83);
-      tint_array_wrapper const tint_symbol_34 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+      tint_array<int, 10> const tint_symbol_34 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       QuicksortObject const tint_symbol_35 = {.numbers=tint_symbol_34};
       *(tint_symbol_83) = tint_symbol_35;
       *(tint_symbol_83) = x_1104;
@@ -809,13 +818,13 @@
   uv = x_717;
   i_2 = 0;
   QuicksortObject const x_721 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_36 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_36 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_37 = {.numbers=tint_symbol_36};
   *(tint_symbol_84) = tint_symbol_37;
   *(tint_symbol_84) = x_721;
   if (true) {
     QuicksortObject const x_722 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_38 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_38 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_39 = {.numbers=tint_symbol_38};
     *(tint_symbol_84) = tint_symbol_39;
     *(tint_symbol_84) = x_722;
@@ -829,13 +838,13 @@
     color = x_725;
     float2 const x_432 = float2(x_431[1], x_431[1]);
     QuicksortObject const x_726 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_40 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_40 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_41 = {.numbers=tint_symbol_40};
     *(tint_symbol_84) = tint_symbol_41;
     *(tint_symbol_84) = x_726;
   }
   QuicksortObject const x_756 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_42 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_42 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_43 = {.numbers=tint_symbol_42};
   *(tint_symbol_84) = tint_symbol_43;
   *(tint_symbol_84) = x_756;
@@ -845,7 +854,7 @@
   i_2 = x_757;
   quicksort_(tint_symbol_84);
   QuicksortObject const x_758 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_44 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_44 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_45 = {.numbers=tint_symbol_44};
   *(tint_symbol_84) = tint_symbol_45;
   *(tint_symbol_84) = x_758;
@@ -860,7 +869,7 @@
   float2 const x_185 = float2(x_184[0], x_184[1]);
   float3 const x_448 = float3(x_185[1], x_446[1], x_446[1]);
   QuicksortObject const x_761 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_46 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_46 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_47 = {.numbers=tint_symbol_46};
   *(tint_symbol_84) = tint_symbol_47;
   *(tint_symbol_84) = x_761;
@@ -869,7 +878,7 @@
   uv = x_762;
   float2 const x_191 = (*(tint_symbol_86)).resolution;
   QuicksortObject const x_763 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_48 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_48 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_49 = {.numbers=tint_symbol_48};
   *(tint_symbol_84) = tint_symbol_49;
   *(tint_symbol_84) = x_763;
@@ -879,7 +888,7 @@
   color = x_764;
   float2 const x_192 = (x_185 / x_191);
   QuicksortObject const x_765 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_50 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_50 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_51 = {.numbers=tint_symbol_50};
   *(tint_symbol_84) = tint_symbol_51;
   *(tint_symbol_84) = x_765;
@@ -897,22 +906,22 @@
   color = x_768;
   float3 const x_451 = float3(x_185[0], x_185[1], x_446[1]);
   QuicksortObject const x_769 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_52 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_52 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_53 = {.numbers=tint_symbol_52};
   *(tint_symbol_84) = tint_symbol_53;
   *(tint_symbol_84) = x_769;
-  int const x_770 = (*(tint_symbol_84)).numbers.arr[0u];
-  (*(tint_symbol_84)).numbers.arr[0u] = 0;
-  (*(tint_symbol_84)).numbers.arr[0u] = x_770;
-  int const x_201 = (*(tint_symbol_84)).numbers.arr[0u];
+  int const x_770 = (*(tint_symbol_84)).numbers[0u];
+  (*(tint_symbol_84)).numbers[0u] = 0;
+  (*(tint_symbol_84)).numbers[0u] = x_770;
+  int const x_201 = (*(tint_symbol_84)).numbers[0u];
   QuicksortObject const x_771 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_54 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_54 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_55 = {.numbers=tint_symbol_54};
   *(tint_symbol_84) = tint_symbol_55;
   *(tint_symbol_84) = x_771;
-  int const x_772 = (*(tint_symbol_84)).numbers.arr[0u];
-  (*(tint_symbol_84)).numbers.arr[0u] = 0;
-  (*(tint_symbol_84)).numbers.arr[0u] = x_772;
+  int const x_772 = (*(tint_symbol_84)).numbers[0u];
+  (*(tint_symbol_84)).numbers[0u] = 0;
+  (*(tint_symbol_84)).numbers[0u] = x_772;
   float const x_206 = color[0];
   float const x_773 = color[0];
   color[0] = 0.0f;
@@ -922,7 +931,7 @@
   i_2 = 0;
   i_2 = x_774;
   QuicksortObject const x_775 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_56 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_56 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_57 = {.numbers=tint_symbol_56};
   *(tint_symbol_84) = tint_symbol_57;
   *(tint_symbol_84) = x_775;
@@ -941,7 +950,7 @@
   uv[0] = 0.0f;
   uv[0] = x_778;
   QuicksortObject const x_779 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_58 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_58 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_59 = {.numbers=tint_symbol_58};
   *(tint_symbol_84) = tint_symbol_59;
   *(tint_symbol_84) = x_779;
@@ -949,16 +958,16 @@
     int const x_780 = i_2;
     i_2 = 0;
     i_2 = x_780;
-    int const x_781 = (*(tint_symbol_84)).numbers.arr[0u];
-    (*(tint_symbol_84)).numbers.arr[0u] = 0;
-    (*(tint_symbol_84)).numbers.arr[0u] = x_781;
+    int const x_781 = (*(tint_symbol_84)).numbers[0u];
+    (*(tint_symbol_84)).numbers[0u] = 0;
+    (*(tint_symbol_84)).numbers[0u] = x_781;
     float3 const x_456 = float3(float2(0.0f)[1], x_448[1], x_448[1]);
     float const x_782 = uv[0];
     uv[0] = 0.0f;
     uv[0] = x_782;
-    int const x_216 = (*(tint_symbol_84)).numbers.arr[1];
+    int const x_216 = (*(tint_symbol_84)).numbers[1];
     QuicksortObject const x_783 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_60 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_60 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_61 = {.numbers=tint_symbol_60};
     *(tint_symbol_84) = tint_symbol_61;
     *(tint_symbol_84) = x_783;
@@ -967,7 +976,7 @@
     uv = float2(0.0f);
     uv = x_784;
     QuicksortObject const x_785 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_62 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_62 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_63 = {.numbers=tint_symbol_62};
     *(tint_symbol_84) = tint_symbol_63;
     *(tint_symbol_84) = x_785;
@@ -990,9 +999,9 @@
     color[0] = 0.0f;
     color[0] = x_790;
     color[0] = (float(x_216) + x_219);
-    int const x_791 = (*(tint_symbol_84)).numbers.arr[0u];
-    (*(tint_symbol_84)).numbers.arr[0u] = 0;
-    (*(tint_symbol_84)).numbers.arr[0u] = x_791;
+    int const x_791 = (*(tint_symbol_84)).numbers[0u];
+    (*(tint_symbol_84)).numbers[0u] = 0;
+    (*(tint_symbol_84)).numbers[0u] = x_791;
   }
   float const x_792 = uv[0];
   uv[0] = 0.0f;
@@ -1030,24 +1039,24 @@
     float const x_801 = color[0];
     color[0] = 0.0f;
     color[0] = x_801;
-    int const x_230 = (*(tint_symbol_84)).numbers.arr[2u];
+    int const x_230 = (*(tint_symbol_84)).numbers[2u];
     float const x_802 = uv[0];
     uv[0] = 0.0f;
     uv[0] = x_802;
     float const x_803 = color[0];
     color[0] = 0.0f;
     color[0] = x_803;
-    int const x_804 = (*(tint_symbol_84)).numbers.arr[2u];
-    (*(tint_symbol_84)).numbers.arr[2u] = 0;
-    (*(tint_symbol_84)).numbers.arr[2u] = x_804;
+    int const x_804 = (*(tint_symbol_84)).numbers[2u];
+    (*(tint_symbol_84)).numbers[2u] = 0;
+    (*(tint_symbol_84)).numbers[2u] = x_804;
     float2 const x_464 = float2(x_450[1], x_191[0]);
     float const x_805 = color[1];
     color[1] = 0.0f;
     color[1] = x_805;
     float const x_234 = color[1];
-    int const x_806 = (*(tint_symbol_84)).numbers.arr[2u];
-    (*(tint_symbol_84)).numbers.arr[2u] = 0;
-    (*(tint_symbol_84)).numbers.arr[2u] = x_806;
+    int const x_806 = (*(tint_symbol_84)).numbers[2u];
+    (*(tint_symbol_84)).numbers[2u] = 0;
+    (*(tint_symbol_84)).numbers[2u] = x_806;
     float2 const x_465 = float2(x_463[0], x_185[0]);
     float const x_807 = color[0];
     color[0] = 0.0f;
@@ -1082,12 +1091,12 @@
     float const x_815 = color[0];
     color[0] = 0.0f;
     color[0] = x_815;
-    int const x_245 = (*(tint_symbol_84)).numbers.arr[3];
+    int const x_245 = (*(tint_symbol_84)).numbers[3];
     float const x_816 = color[0];
     color[0] = 0.0f;
     color[0] = x_816;
     QuicksortObject const x_817 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_64 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_64 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_65 = {.numbers=tint_symbol_64};
     *(tint_symbol_84) = tint_symbol_65;
     *(tint_symbol_84) = x_817;
@@ -1106,9 +1115,9 @@
     float const x_821 = color[2];
     color[2] = 0.0f;
     color[2] = x_821;
-    int const x_822 = (*(tint_symbol_84)).numbers.arr[0u];
-    (*(tint_symbol_84)).numbers.arr[0u] = 0;
-    (*(tint_symbol_84)).numbers.arr[0u] = x_822;
+    int const x_822 = (*(tint_symbol_84)).numbers[0u];
+    (*(tint_symbol_84)).numbers[0u] = 0;
+    (*(tint_symbol_84)).numbers[0u] = x_822;
     float2 const x_470 = float2(float2(0.0f)[0], float2(0.0f)[1]);
     float const x_823 = color[2];
     color[2] = 0.0f;
@@ -1123,7 +1132,7 @@
   uv[0] = 0.0f;
   uv[0] = x_825;
   float3 const x_472 = float3(x_454[0], x_454[1], x_454[1]);
-  int const x_254 = (*(tint_symbol_84)).numbers.arr[4];
+  int const x_254 = (*(tint_symbol_84)).numbers[4];
   float const x_826 = uv[0];
   uv[0] = 0.0f;
   uv[0] = x_826;
@@ -1131,9 +1140,9 @@
   color = float3(0.0f);
   color = x_827;
   float3 const x_473 = float3(x_446[1], x_453[0], x_453[0]);
-  int const x_828 = (*(tint_symbol_84)).numbers.arr[4];
-  (*(tint_symbol_84)).numbers.arr[4] = 0;
-  (*(tint_symbol_84)).numbers.arr[4] = x_828;
+  int const x_828 = (*(tint_symbol_84)).numbers[4];
+  (*(tint_symbol_84)).numbers[4] = 0;
+  (*(tint_symbol_84)).numbers[4] = x_828;
   float2 const x_474 = float2(x_191[0], x_184[2]);
   float const x_829 = uv[0];
   uv[0] = 0.0f;
@@ -1167,9 +1176,9 @@
   i_2 = 0;
   i_2 = x_836;
   float3 const x_479 = float3(float2(0.0f)[1], x_454[1], float2(0.0f)[0]);
-  int const x_837 = (*(tint_symbol_84)).numbers.arr[0u];
-  (*(tint_symbol_84)).numbers.arr[0u] = 0;
-  (*(tint_symbol_84)).numbers.arr[0u] = x_837;
+  int const x_837 = (*(tint_symbol_84)).numbers[0u];
+  (*(tint_symbol_84)).numbers[0u] = 0;
+  (*(tint_symbol_84)).numbers[0u] = x_837;
   float const x_838 = color[1];
   color[1] = 0.0f;
   color[1] = x_838;
@@ -1182,7 +1191,7 @@
     float3 const x_840 = color;
     color = float3(0.0f);
     color = x_840;
-    int const x_267 = (*(tint_symbol_84)).numbers.arr[5u];
+    int const x_267 = (*(tint_symbol_84)).numbers[5u];
     float const x_841 = color[0];
     color[0] = 0.0f;
     color[0] = x_841;
@@ -1198,7 +1207,7 @@
     uv[0] = x_844;
     float3 const x_482 = float3(x_455[0], x_475[1], x_455[1]);
     QuicksortObject const x_845 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_66 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_66 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_67 = {.numbers=tint_symbol_66};
     *(tint_symbol_84) = tint_symbol_67;
     *(tint_symbol_84) = x_845;
@@ -1225,13 +1234,13 @@
   float const x_851 = uv[1];
   uv[1] = 0.0f;
   uv[1] = x_851;
-  int const x_852 = (*(tint_symbol_84)).numbers.arr[4];
-  (*(tint_symbol_84)).numbers.arr[4] = 0;
-  (*(tint_symbol_84)).numbers.arr[4] = x_852;
+  int const x_852 = (*(tint_symbol_84)).numbers[4];
+  (*(tint_symbol_84)).numbers[4] = 0;
+  (*(tint_symbol_84)).numbers[4] = x_852;
   float const x_274 = uv[1];
-  int const x_853 = (*(tint_symbol_84)).numbers.arr[0u];
-  (*(tint_symbol_84)).numbers.arr[0u] = 0;
-  (*(tint_symbol_84)).numbers.arr[0u] = x_853;
+  int const x_853 = (*(tint_symbol_84)).numbers[0u];
+  (*(tint_symbol_84)).numbers[0u] = 0;
+  (*(tint_symbol_84)).numbers[0u] = x_853;
   if ((x_274 > 0.5f)) {
     float const x_854 = uv[0];
     uv[0] = 0.0f;
@@ -1244,16 +1253,16 @@
     float const x_856 = uv[1];
     uv[1] = 0.0f;
     uv[1] = x_856;
-    int const x_280 = (*(tint_symbol_84)).numbers.arr[6u];
+    int const x_280 = (*(tint_symbol_84)).numbers[6u];
     float const x_857 = uv[1];
     uv[1] = 0.0f;
     uv[1] = x_857;
     int const x_858 = i_2;
     i_2 = 0;
     i_2 = x_858;
-    int const x_859 = (*(tint_symbol_84)).numbers.arr[4];
-    (*(tint_symbol_84)).numbers.arr[4] = 0;
-    (*(tint_symbol_84)).numbers.arr[4] = x_859;
+    int const x_859 = (*(tint_symbol_84)).numbers[4];
+    (*(tint_symbol_84)).numbers[4] = 0;
+    (*(tint_symbol_84)).numbers[4] = x_859;
     float2 const x_488 = float2(x_473[2], x_473[1]);
     float const x_283 = color[1];
     float2 const x_860 = uv;
@@ -1263,15 +1272,15 @@
     color[0] = 0.0f;
     color[0] = x_861;
     float2 const x_489 = float2(x_475[1], x_475[0]);
-    int const x_862 = (*(tint_symbol_84)).numbers.arr[6u];
-    (*(tint_symbol_84)).numbers.arr[6u] = 0;
-    (*(tint_symbol_84)).numbers.arr[6u] = x_862;
-    int const x_863 = (*(tint_symbol_84)).numbers.arr[6u];
-    (*(tint_symbol_84)).numbers.arr[6u] = 0;
-    (*(tint_symbol_84)).numbers.arr[6u] = x_863;
+    int const x_862 = (*(tint_symbol_84)).numbers[6u];
+    (*(tint_symbol_84)).numbers[6u] = 0;
+    (*(tint_symbol_84)).numbers[6u] = x_862;
+    int const x_863 = (*(tint_symbol_84)).numbers[6u];
+    (*(tint_symbol_84)).numbers[6u] = 0;
+    (*(tint_symbol_84)).numbers[6u] = x_863;
     float2 const x_490 = float2(x_480[2], x_480[2]);
     QuicksortObject const x_864 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_68 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_68 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_69 = {.numbers=tint_symbol_68};
     *(tint_symbol_84) = tint_symbol_69;
     *(tint_symbol_84) = x_864;
@@ -1290,7 +1299,7 @@
   color[0] = x_867;
   float const x_287 = uv[1];
   QuicksortObject const x_868 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_70 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_70 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_71 = {.numbers=tint_symbol_70};
   *(tint_symbol_84) = tint_symbol_71;
   *(tint_symbol_84) = x_868;
@@ -1302,9 +1311,9 @@
   color[1] = 0.0f;
   color[1] = x_870;
   float3 const x_494 = float3(x_191[0], x_191[1], x_191[1]);
-  int const x_871 = (*(tint_symbol_84)).numbers.arr[4];
-  (*(tint_symbol_84)).numbers.arr[4] = 0;
-  (*(tint_symbol_84)).numbers.arr[4] = x_871;
+  int const x_871 = (*(tint_symbol_84)).numbers[4];
+  (*(tint_symbol_84)).numbers[4] = 0;
+  (*(tint_symbol_84)).numbers[4] = x_871;
   if ((x_287 > 0.75f)) {
     float3 const x_872 = color;
     color = float3(0.0f);
@@ -1316,7 +1325,7 @@
     float3 const x_874 = color;
     color = float3(0.0f);
     color = x_874;
-    int const x_293 = (*(tint_symbol_84)).numbers.arr[7];
+    int const x_293 = (*(tint_symbol_84)).numbers[7];
     float const x_875 = uv[0];
     uv[0] = 0.0f;
     uv[0] = x_875;
@@ -1325,9 +1334,9 @@
     color[1] = 0.0f;
     color[1] = x_876;
     float2 const x_497 = float2(x_477[0], x_461[1]);
-    int const x_877 = (*(tint_symbol_84)).numbers.arr[0u];
-    (*(tint_symbol_84)).numbers.arr[0u] = 0;
-    (*(tint_symbol_84)).numbers.arr[0u] = x_877;
+    int const x_877 = (*(tint_symbol_84)).numbers[0u];
+    (*(tint_symbol_84)).numbers[0u] = 0;
+    (*(tint_symbol_84)).numbers[0u] = x_877;
     float const x_878 = color[1];
     color[1] = 0.0f;
     color[1] = x_878;
@@ -1369,14 +1378,14 @@
   float2 const x_888 = uv;
   uv = float2(0.0f);
   uv = x_888;
-  int const x_301 = (*(tint_symbol_84)).numbers.arr[8];
+  int const x_301 = (*(tint_symbol_84)).numbers[8];
   int const x_889 = i_2;
   i_2 = 0;
   i_2 = x_889;
   float2 const x_503 = float2(x_185[0], x_451[2]);
-  int const x_890 = (*(tint_symbol_84)).numbers.arr[8];
-  (*(tint_symbol_84)).numbers.arr[8] = 0;
-  (*(tint_symbol_84)).numbers.arr[8] = x_890;
+  int const x_890 = (*(tint_symbol_84)).numbers[8];
+  (*(tint_symbol_84)).numbers[8] = 0;
+  (*(tint_symbol_84)).numbers[8] = x_890;
   float const x_891 = color[1];
   color[1] = 0.0f;
   color[1] = x_891;
@@ -1393,9 +1402,9 @@
   color[0] = 0.0f;
   color[0] = x_894;
   float2 const x_506 = float2(x_493[0], x_492[0]);
-  int const x_895 = (*(tint_symbol_84)).numbers.arr[4];
-  (*(tint_symbol_84)).numbers.arr[4] = 0;
-  (*(tint_symbol_84)).numbers.arr[4] = x_895;
+  int const x_895 = (*(tint_symbol_84)).numbers[4];
+  (*(tint_symbol_84)).numbers[4] = 0;
+  (*(tint_symbol_84)).numbers[4] = x_895;
   float const x_896 = uv[1];
   uv[1] = 0.0f;
   uv[1] = x_896;
@@ -1444,23 +1453,23 @@
   uv[1] = 0.0f;
   uv[1] = x_908;
   float3 const x_512 = float3(x_455[1], x_455[1], x_455[1]);
-  int const x_909 = (*(tint_symbol_84)).numbers.arr[4];
-  (*(tint_symbol_84)).numbers.arr[4] = 0;
-  (*(tint_symbol_84)).numbers.arr[4] = x_909;
+  int const x_909 = (*(tint_symbol_84)).numbers[4];
+  (*(tint_symbol_84)).numbers[4] = 0;
+  (*(tint_symbol_84)).numbers[4] = x_909;
   if ((fabs((x_308 - x_310)) < 0.25f)) {
     float const x_910 = uv[0];
     uv[0] = 0.0f;
     uv[0] = x_910;
     QuicksortObject const x_911 = *(tint_symbol_84);
-    tint_array_wrapper const tint_symbol_72 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+    tint_array<int, 10> const tint_symbol_72 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     QuicksortObject const tint_symbol_73 = {.numbers=tint_symbol_72};
     *(tint_symbol_84) = tint_symbol_73;
     *(tint_symbol_84) = x_911;
     float3 const x_513 = float3(x_505[2], x_505[0], x_448[0]);
-    int const x_912 = (*(tint_symbol_84)).numbers.arr[8];
-    (*(tint_symbol_84)).numbers.arr[8] = 0;
-    (*(tint_symbol_84)).numbers.arr[8] = x_912;
-    int const x_317 = (*(tint_symbol_84)).numbers.arr[9u];
+    int const x_912 = (*(tint_symbol_84)).numbers[8];
+    (*(tint_symbol_84)).numbers[8] = 0;
+    (*(tint_symbol_84)).numbers[8] = x_912;
+    int const x_317 = (*(tint_symbol_84)).numbers[9u];
     float3 const x_514 = float3(x_474[1], x_474[1], x_474[1]);
     float const x_913 = uv[1];
     uv[1] = 0.0f;
@@ -1506,12 +1515,12 @@
   uv[0] = 0.0f;
   uv[0] = x_923;
   QuicksortObject const x_924 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_74 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_74 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_75 = {.numbers=tint_symbol_74};
   *(tint_symbol_84) = tint_symbol_75;
   *(tint_symbol_84) = x_924;
   QuicksortObject const x_925 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_76 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_76 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_77 = {.numbers=tint_symbol_76};
   *(tint_symbol_84) = tint_symbol_77;
   *(tint_symbol_84) = x_925;
@@ -1532,7 +1541,7 @@
   uv[0] = x_929;
   *(tint_symbol_87) = x_330;
   QuicksortObject const x_930 = *(tint_symbol_84);
-  tint_array_wrapper const tint_symbol_78 = {.arr={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  tint_array<int, 10> const tint_symbol_78 = tint_array<int, 10>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   QuicksortObject const tint_symbol_79 = {.numbers=tint_symbol_78};
   *(tint_symbol_84) = tint_symbol_79;
   *(tint_symbol_84) = x_930;
diff --git a/test/tint/bug/tint/757.wgsl.expected.msl b/test/tint/bug/tint/757.wgsl.expected.msl
index 35bf540..b0644d0 100644
--- a/test/tint/bug/tint/757.wgsl.expected.msl
+++ b/test/tint/bug/tint/757.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Constants {
   int level;
 };
 
 struct Result {
-  /* 0x0000 */ float values[1];
+  /* 0x0000 */ tint_array<float, 1> values;
 };
 
 void tint_symbol_inner(uint3 GlobalInvocationID, texture2d_array<float, access::sample> tint_symbol_1, device Result* const tint_symbol_2) {
diff --git a/test/tint/bug/tint/782.wgsl.expected.msl b/test/tint/bug/tint/782.wgsl.expected.msl
index a568ecb..0d4e877 100644
--- a/test/tint/bug/tint/782.wgsl.expected.msl
+++ b/test/tint/bug/tint/782.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[2];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void foo() {
-  tint_array_wrapper tint_symbol = {};
-  tint_array_wrapper implict = {};
+  tint_array<int, 2> tint_symbol = {};
+  tint_array<int, 2> implict = {};
   implict = tint_symbol;
 }
 
diff --git a/test/tint/bug/tint/824.wgsl.expected.msl b/test/tint/bug/tint/824.wgsl.expected.msl
index c9a884c..4427773 100644
--- a/test/tint/bug/tint/824.wgsl.expected.msl
+++ b/test/tint/bug/tint/824.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Output {
   float4 Position;
   float4 color;
@@ -11,21 +24,13 @@
   float4 Position [[position]];
 };
 
-struct tint_array_wrapper {
-  float2 arr[4];
-};
-
-struct tint_array_wrapper_1 {
-  float4 arr[4];
-};
-
 Output tint_symbol_inner(uint VertexIndex, uint InstanceIndex) {
-  tint_array_wrapper const zv = {.arr={float2(0.200000003f), float2(0.300000012f), float2(-0.100000001f), float2(1.100000024f)}};
-  float const z = zv.arr[InstanceIndex][0];
+  tint_array<float2, 4> const zv = tint_array<float2, 4>{float2(0.200000003f), float2(0.300000012f), float2(-0.100000001f), float2(1.100000024f)};
+  float const z = zv[InstanceIndex][0];
   Output output = {};
   output.Position = float4(0.5f, 0.5f, z, 1.0f);
-  tint_array_wrapper_1 const colors = {.arr={float4(1.0f, 0.0f, 0.0f, 1.0f), float4(0.0f, 1.0f, 0.0f, 1.0f), float4(0.0f, 0.0f, 1.0f, 1.0f), float4(1.0f)}};
-  output.color = colors.arr[InstanceIndex];
+  tint_array<float4, 4> const colors = tint_array<float4, 4>{float4(1.0f, 0.0f, 0.0f, 1.0f), float4(0.0f, 1.0f, 0.0f, 1.0f), float4(0.0f, 0.0f, 1.0f, 1.0f), float4(1.0f)};
+  output.color = colors[InstanceIndex];
   return output;
 }
 
diff --git a/test/tint/bug/tint/827.wgsl.expected.msl b/test/tint/bug/tint/827.wgsl.expected.msl
index 532283a..4ea4405 100644
--- a/test/tint/bug/tint/827.wgsl.expected.msl
+++ b/test/tint/bug/tint/827.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Result {
-  /* 0x0000 */ float values[1];
+  /* 0x0000 */ tint_array<float, 1> values;
 };
 
 constant uint width = 128u;
diff --git a/test/tint/bug/tint/870.spvasm.expected.msl b/test/tint/bug/tint/870.spvasm.expected.msl
index 05b9e33..9a97441 100644
--- a/test/tint/bug/tint/870.spvasm.expected.msl
+++ b/test/tint/bug/tint/870.spvasm.expected.msl
@@ -1,15 +1,24 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int arr[6];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct sspp962805860buildInformationS {
   /* 0x0000 */ float4 footprint;
   /* 0x0010 */ float4 offset;
   /* 0x0020 */ int essence;
-  /* 0x0024 */ tint_array_wrapper orientation;
+  /* 0x0024 */ tint_array<int, 6> orientation;
 };
 
 struct x_B4_BuildInformation {
@@ -17,14 +26,14 @@
 };
 
 void main_1(const device x_B4_BuildInformation* const tint_symbol_1) {
-  tint_array_wrapper orientation = {};
-  tint_array_wrapper const x_23 = (*(tint_symbol_1)).passthru.orientation;
-  orientation.arr[0] = x_23.arr[0u];
-  orientation.arr[1] = x_23.arr[1u];
-  orientation.arr[2] = x_23.arr[2u];
-  orientation.arr[3] = x_23.arr[3u];
-  orientation.arr[4] = x_23.arr[4u];
-  orientation.arr[5] = x_23.arr[5u];
+  tint_array<int, 6> orientation = {};
+  tint_array<int, 6> const x_23 = (*(tint_symbol_1)).passthru.orientation;
+  orientation[0] = x_23[0u];
+  orientation[1] = x_23[1u];
+  orientation[2] = x_23[2u];
+  orientation[3] = x_23[3u];
+  orientation[4] = x_23[4u];
+  orientation[5] = x_23[5u];
   return;
 }
 
diff --git a/test/tint/bug/tint/913.wgsl.expected.msl b/test/tint/bug/tint/913.wgsl.expected.msl
index e326a9b..3acacc7 100644
--- a/test/tint/bug/tint/913.wgsl.expected.msl
+++ b/test/tint/bug/tint/913.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint dstTextureFlipY;
   /* 0x0004 */ uint channelCount;
@@ -10,7 +23,7 @@
 };
 
 struct OutputBuf {
-  /* 0x0000 */ uint result[1];
+  /* 0x0000 */ tint_array<uint, 1> result;
 };
 
 bool aboutEqual(float value, float expect) {
diff --git a/test/tint/bug/tint/914.wgsl.expected.msl b/test/tint/bug/tint/914.wgsl.expected.msl
index c6aad93..b7a253c 100644
--- a/test/tint/bug/tint/914.wgsl.expected.msl
+++ b/test/tint/bug/tint/914.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint dimAOuter;
   /* 0x0004 */ uint dimInner;
@@ -8,7 +21,7 @@
 };
 
 struct Matrix {
-  /* 0x0000 */ float numbers[1];
+  /* 0x0000 */ tint_array<float, 1> numbers;
 };
 
 float mm_readA(uint row, uint col, const constant Uniforms* const tint_symbol_3, const device Matrix* const tint_symbol_4) {
@@ -44,28 +57,12 @@
 
 constant uint TileInner = 64u;
 
-struct tint_array_wrapper_1 {
-  float arr[64];
-};
-
-struct tint_array_wrapper {
-  tint_array_wrapper_1 arr[64];
-};
-
-struct tint_array_wrapper_2 {
-  float arr[16];
-};
-
-struct tint_array_wrapper_3 {
-  float arr[4];
-};
-
-void tint_symbol_inner(uint3 local_id, uint3 global_id, uint local_invocation_index, threadgroup tint_array_wrapper* const tint_symbol_9, threadgroup tint_array_wrapper* const tint_symbol_10, const constant Uniforms* const tint_symbol_11, const device Matrix* const tint_symbol_12, const device Matrix* const tint_symbol_13, device Matrix* const tint_symbol_14) {
+void tint_symbol_inner(uint3 local_id, uint3 global_id, uint local_invocation_index, threadgroup tint_array<tint_array<float, 64>, 64>* const tint_symbol_9, threadgroup tint_array<tint_array<float, 64>, 64>* const tint_symbol_10, const constant Uniforms* const tint_symbol_11, const device Matrix* const tint_symbol_12, const device Matrix* const tint_symbol_13, device Matrix* const tint_symbol_14) {
   for(uint idx = local_invocation_index; (idx < 4096u); idx = (idx + 256u)) {
     uint const i = (idx / 64u);
     uint const i_1 = (idx % 64u);
-    (*(tint_symbol_9)).arr[i].arr[i_1] = 0.0f;
-    (*(tint_symbol_10)).arr[i].arr[i_1] = 0.0f;
+    (*(tint_symbol_9))[i][i_1] = 0.0f;
+    (*(tint_symbol_10))[i][i_1] = 0.0f;
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
   uint const tileRow = (local_id[1] * 4u);
@@ -73,11 +70,11 @@
   uint const globalRow = (global_id[1] * 4u);
   uint const globalCol = (global_id[0] * 4u);
   uint const numTiles = ((((*(tint_symbol_11)).dimInner - 1u) / 64u) + 1u);
-  tint_array_wrapper_2 acc = {};
+  tint_array<float, 16> acc = {};
   float ACached = 0.0f;
-  tint_array_wrapper_3 BCached = {};
+  tint_array<float, 4> BCached = {};
   for(uint index = 0u; (index < (4u * 4u)); index = (index + 1u)) {
-    acc.arr[index] = 0.0f;
+    acc[index] = 0.0f;
   }
   uint const ColPerThreadA = (64u / 16u);
   uint const tileColA = (local_id[0] * ColPerThreadA);
@@ -89,7 +86,7 @@
         uint const inputRow = (tileRow + innerRow);
         uint const inputCol = (tileColA + innerCol);
         float const tint_symbol_1 = mm_readA((globalRow + innerRow), ((t * 64u) + inputCol), tint_symbol_11, tint_symbol_12);
-        (*(tint_symbol_9)).arr[inputRow].arr[inputCol] = tint_symbol_1;
+        (*(tint_symbol_9))[inputRow][inputCol] = tint_symbol_1;
       }
     }
     for(uint innerRow = 0u; (innerRow < RowPerThreadB); innerRow = (innerRow + 1u)) {
@@ -97,19 +94,19 @@
         uint const inputRow = (tileRowB + innerRow);
         uint const inputCol = (tileCol + innerCol);
         float const tint_symbol_2 = mm_readB(((t * 64u) + inputRow), (globalCol + innerCol), tint_symbol_11, tint_symbol_13);
-        (*(tint_symbol_10)).arr[innerCol].arr[inputCol] = tint_symbol_2;
+        (*(tint_symbol_10))[innerCol][inputCol] = tint_symbol_2;
       }
     }
     threadgroup_barrier(mem_flags::mem_threadgroup);
     for(uint k = 0u; (k < 64u); k = (k + 1u)) {
       for(uint inner = 0u; (inner < 4u); inner = (inner + 1u)) {
-        BCached.arr[inner] = (*(tint_symbol_10)).arr[k].arr[(tileCol + inner)];
+        BCached[inner] = (*(tint_symbol_10))[k][(tileCol + inner)];
       }
       for(uint innerRow = 0u; (innerRow < 4u); innerRow = (innerRow + 1u)) {
-        ACached = (*(tint_symbol_9)).arr[(tileRow + innerRow)].arr[k];
+        ACached = (*(tint_symbol_9))[(tileRow + innerRow)][k];
         for(uint innerCol = 0u; (innerCol < 4u); innerCol = (innerCol + 1u)) {
           uint const index = ((innerRow * 4u) + innerCol);
-          acc.arr[index] = (acc.arr[index] + (ACached * BCached.arr[innerCol]));
+          acc[index] = (acc[index] + (ACached * BCached[innerCol]));
         }
       }
     }
@@ -118,14 +115,14 @@
   for(uint innerRow = 0u; (innerRow < 4u); innerRow = (innerRow + 1u)) {
     for(uint innerCol = 0u; (innerCol < 4u); innerCol = (innerCol + 1u)) {
       uint const index = ((innerRow * 4u) + innerCol);
-      mm_write((globalRow + innerRow), (globalCol + innerCol), acc.arr[index], tint_symbol_11, tint_symbol_14);
+      mm_write((globalRow + innerRow), (globalCol + innerCol), acc[index], tint_symbol_11, tint_symbol_14);
     }
   }
 }
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_17 [[buffer(0)]], const device Matrix* tint_symbol_18 [[buffer(2)]], const device Matrix* tint_symbol_19 [[buffer(3)]], device Matrix* tint_symbol_20 [[buffer(1)]], uint3 local_id [[thread_position_in_threadgroup]], uint3 global_id [[thread_position_in_grid]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
-  threadgroup tint_array_wrapper tint_symbol_15;
-  threadgroup tint_array_wrapper tint_symbol_16;
+  threadgroup tint_array<tint_array<float, 64>, 64> tint_symbol_15;
+  threadgroup tint_array<tint_array<float, 64>, 64> tint_symbol_16;
   tint_symbol_inner(local_id, global_id, local_invocation_index, &(tint_symbol_15), &(tint_symbol_16), tint_symbol_17, tint_symbol_18, tint_symbol_19, tint_symbol_20);
   return;
 }
diff --git a/test/tint/bug/tint/922.wgsl.expected.msl b/test/tint/bug/tint/922.wgsl.expected.msl
index 584f9e4..56d2fe7 100644
--- a/test/tint/bug/tint/922.wgsl.expected.msl
+++ b/test/tint/bug/tint/922.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Mat4x4_ {
   /* 0x0000 */ float4 mx;
   /* 0x0010 */ float4 my;
@@ -23,21 +36,13 @@
   /* 0x0000 */ Mat4x4_ u_Projection;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ Mat4x2_ arr[1];
-};
-
 struct ub_MaterialParams {
-  /* 0x0000 */ tint_array_wrapper u_TexMtx;
+  /* 0x0000 */ tint_array<Mat4x2_, 1> u_TexMtx;
   /* 0x0020 */ float4 u_Misc0_;
 };
 
-struct tint_array_wrapper_1 {
-  /* 0x0000 */ Mat4x3_ arr[32];
-};
-
 struct ub_PacketParams {
-  /* 0x0000 */ tint_array_wrapper_1 u_PosMtx;
+  /* 0x0000 */ tint_array<Mat4x3_, 32> u_PosMtx;
 };
 
 struct VertexOutput {
@@ -222,7 +227,7 @@
   Mat4x3_ t_PosMtx = {};
   float2 t_TexSpaceCoord = 0.0f;
   float const x_e15 = *(tint_symbol_5);
-  Mat4x3_ const x_e18 = (*(tint_symbol_6)).u_PosMtx.arr[int(x_e15)];
+  Mat4x3_ const x_e18 = (*(tint_symbol_6)).u_PosMtx[int(x_e15)];
   t_PosMtx = x_e18;
   Mat4x3_ const x_e23 = t_PosMtx;
   Mat4x4_ const x_e24 = x_Mat4x4_1(x_e23);
@@ -247,7 +252,7 @@
   if ((x_e52[0] == 2.0f)) {
     {
       float3 const x_e59 = *(tint_symbol_13);
-      Mat4x2_ const x_e64 = (*(tint_symbol_12)).u_TexMtx.arr[0];
+      Mat4x2_ const x_e64 = (*(tint_symbol_12)).u_TexMtx[0];
       float3 const x_e65 = *(tint_symbol_13);
       float2 const x_e68 = Mul2(x_e64, float4(x_e65, 1.0f));
       *(tint_symbol_14) = float2(x_e68).xy;
@@ -256,7 +261,7 @@
   } else {
     {
       float2 const x_e73 = *(tint_symbol_15);
-      Mat4x2_ const x_e79 = (*(tint_symbol_12)).u_TexMtx.arr[0];
+      Mat4x2_ const x_e79 = (*(tint_symbol_12)).u_TexMtx[0];
       float2 const x_e80 = *(tint_symbol_15);
       float2 const x_e84 = Mul2(x_e79, float4(x_e80, 1.0f, 1.0f));
       *(tint_symbol_14) = float2(x_e84).xy;
diff --git a/test/tint/bug/tint/942.wgsl.expected.msl b/test/tint/bug/tint/942.wgsl.expected.msl
index 6693f72..cca7a67 100644
--- a/test/tint/bug/tint/942.wgsl.expected.msl
+++ b/test/tint/bug/tint/942.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Params {
   /* 0x0000 */ uint filterDim;
   /* 0x0004 */ uint blockDim;
@@ -10,19 +23,11 @@
   /* 0x0000 */ uint value;
 };
 
-struct tint_array_wrapper_1 {
-  float3 arr[256];
-};
-
-struct tint_array_wrapper {
-  tint_array_wrapper_1 arr[4];
-};
-
-void tint_symbol_inner(uint3 WorkGroupID, uint3 LocalInvocationID, uint local_invocation_index, threadgroup tint_array_wrapper* const tint_symbol_1, const constant Params* const tint_symbol_2, texture2d<float, access::sample> tint_symbol_3, const constant Flip* const tint_symbol_4, sampler tint_symbol_5, texture2d<float, access::write> tint_symbol_6) {
+void tint_symbol_inner(uint3 WorkGroupID, uint3 LocalInvocationID, uint local_invocation_index, threadgroup tint_array<tint_array<float3, 256>, 4>* const tint_symbol_1, const constant Params* const tint_symbol_2, texture2d<float, access::sample> tint_symbol_3, const constant Flip* const tint_symbol_4, sampler tint_symbol_5, texture2d<float, access::write> tint_symbol_6) {
   for(uint idx = local_invocation_index; (idx < 1024u); idx = (idx + 64u)) {
     uint const i_1 = (idx / 256u);
     uint const i_2 = (idx % 256u);
-    (*(tint_symbol_1)).arr[i_1].arr[i_2] = float3(0.0f);
+    (*(tint_symbol_1))[i_1][i_2] = float3(0.0f);
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
   uint const filterOffset = (((*(tint_symbol_2)).filterDim - 1u) / 2u);
@@ -34,7 +39,7 @@
       if (((*(tint_symbol_4)).value != 0u)) {
         loadIndex = int2(loadIndex).yx;
       }
-      (*(tint_symbol_1)).arr[r].arr[((4u * LocalInvocationID[0]) + c)] = float4(tint_symbol_3.sample(tint_symbol_5, ((float2(loadIndex) + float2(0.25f)) / float2(dims)), level(0.0f))).rgb;
+      (*(tint_symbol_1))[r][((4u * LocalInvocationID[0]) + c)] = float4(tint_symbol_3.sample(tint_symbol_5, ((float2(loadIndex) + float2(0.25f)) / float2(dims)), level(0.0f))).rgb;
     }
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
@@ -49,7 +54,7 @@
         float3 acc = float3(0.0f);
         for(uint f = 0u; (f < (*(tint_symbol_2)).filterDim); f = (f + 1u)) {
           uint i = ((center + f) - filterOffset);
-          acc = (acc + ((1.0f / float((*(tint_symbol_2)).filterDim)) * (*(tint_symbol_1)).arr[r].arr[i]));
+          acc = (acc + ((1.0f / float((*(tint_symbol_2)).filterDim)) * (*(tint_symbol_1))[r][i]));
         }
         tint_symbol_6.write(float4(acc, 1.0f), uint2(writeIndex));
       }
@@ -58,7 +63,7 @@
 }
 
 kernel void tint_symbol(const constant Params* tint_symbol_8 [[buffer(0)]], texture2d<float, access::sample> tint_symbol_9 [[texture(0)]], const constant Flip* tint_symbol_10 [[buffer(1)]], sampler tint_symbol_11 [[sampler(0)]], texture2d<float, access::write> tint_symbol_12 [[texture(1)]], uint3 WorkGroupID [[threadgroup_position_in_grid]], uint3 LocalInvocationID [[thread_position_in_threadgroup]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
-  threadgroup tint_array_wrapper tint_symbol_7;
+  threadgroup tint_array<tint_array<float3, 256>, 4> tint_symbol_7;
   tint_symbol_inner(WorkGroupID, LocalInvocationID, local_invocation_index, &(tint_symbol_7), tint_symbol_8, tint_symbol_9, tint_symbol_10, tint_symbol_11, tint_symbol_12);
   return;
 }
diff --git a/test/tint/bug/tint/943.spvasm.expected.msl b/test/tint/bug/tint/943.spvasm.expected.msl
index 6093a20..48563e2 100644
--- a/test/tint/bug/tint/943.spvasm.expected.msl
+++ b/test/tint/bug/tint/943.spvasm.expected.msl
@@ -4,44 +4,41 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ float tint_symbol;
-  /* 0x0004 */ int8_t tint_pad[12];
+  /* 0x0004 */ tint_array<int8_t, 12> tint_pad;
   /* 0x0010 */ packed_int3 aShape;
-  /* 0x001c */ int8_t tint_pad_1[4];
+  /* 0x001c */ tint_array<int8_t, 4> tint_pad_1;
   /* 0x0020 */ packed_int3 bShape;
-  /* 0x002c */ int8_t tint_pad_2[4];
+  /* 0x002c */ tint_array<int8_t, 4> tint_pad_2;
   /* 0x0030 */ packed_int3 outShape;
-  /* 0x003c */ int8_t tint_pad_3[4];
+  /* 0x003c */ tint_array<int8_t, 4> tint_pad_3;
   /* 0x0040 */ int2 outShapeStrides;
 };
 
 struct ssbOut {
-  /* 0x0000 */ float result[1];
+  /* 0x0000 */ tint_array<float, 1> result;
 };
 
 struct ssbA {
-  /* 0x0000 */ float A[1];
+  /* 0x0000 */ tint_array<float, 1> A;
 };
 
 struct ssbB {
-  /* 0x0000 */ float B[1];
-};
-
-struct tint_array_wrapper_1 {
-  float arr[64];
-};
-
-struct tint_array_wrapper {
-  tint_array_wrapper_1 arr[64];
-};
-
-struct tint_array_wrapper_3 {
-  float arr[1];
-};
-
-struct tint_array_wrapper_2 {
-  tint_array_wrapper_3 arr[64];
+  /* 0x0000 */ tint_array<float, 1> B;
 };
 
 bool coordsInBounds_vi2_vi2_(thread int2* const coord, thread int2* const shape) {
@@ -175,11 +172,7 @@
   return;
 }
 
-struct tint_array_wrapper_4 {
-  tint_array_wrapper_3 arr[1];
-};
-
-void mm_matMul_i1_i1_i1_(thread int* const dimAOuter, thread int* const dimInner, thread int* const dimBOuter, thread uint3* const tint_symbol_19, thread uint3* const tint_symbol_20, const constant Uniforms* const tint_symbol_21, thread int* const tint_symbol_22, thread int* const tint_symbol_23, thread int* const tint_symbol_24, const device ssbA* const tint_symbol_25, threadgroup tint_array_wrapper* const tint_symbol_26, thread int* const tint_symbol_27, const device ssbB* const tint_symbol_28, threadgroup tint_array_wrapper_2* const tint_symbol_29, device ssbOut* const tint_symbol_30) {
+void mm_matMul_i1_i1_i1_(thread int* const dimAOuter, thread int* const dimInner, thread int* const dimBOuter, thread uint3* const tint_symbol_19, thread uint3* const tint_symbol_20, const constant Uniforms* const tint_symbol_21, thread int* const tint_symbol_22, thread int* const tint_symbol_23, thread int* const tint_symbol_24, const device ssbA* const tint_symbol_25, threadgroup tint_array<tint_array<float, 64>, 64>* const tint_symbol_26, thread int* const tint_symbol_27, const device ssbB* const tint_symbol_28, threadgroup tint_array<tint_array<float, 1>, 64>* const tint_symbol_29, device ssbOut* const tint_symbol_30) {
   int tileRow = 0;
   int tileCol = 0;
   int globalRow = 0;
@@ -187,7 +180,7 @@
   int numTiles = 0;
   int innerRow = 0;
   int innerCol = 0;
-  tint_array_wrapper_4 acc = {};
+  tint_array<tint_array<float, 1>, 1> acc = {};
   int tileColA = 0;
   int tileRowB = 0;
   int t = 0;
@@ -205,7 +198,7 @@
   int param_6 = 0;
   int k = 0;
   int inner = 0;
-  tint_array_wrapper_3 BCached = {};
+  tint_array<float, 1> BCached = {};
   int innerRow_3 = 0;
   float ACached = 0.0f;
   int innerCol_3 = 0;
@@ -240,7 +233,7 @@
       }
       int const x_177 = innerRow;
       int const x_178 = innerCol;
-      acc.arr[x_177].arr[x_178] = 0.0f;
+      acc[x_177][x_178] = 0.0f;
       {
         int const x_181 = innerCol;
         innerCol = as_type<int>((as_type<uint>(x_181) + as_type<uint>(1)));
@@ -292,7 +285,7 @@
         param_3 = as_type<int>((as_type<uint>(x_235) + as_type<uint>(x_236)));
         param_4 = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(x_238) * as_type<uint>(64)))) + as_type<uint>(x_240)));
         float const x_244 = mm_readA_i1_i1_(&(param_3), &(param_4), tint_symbol_21, tint_symbol_22, tint_symbol_23, tint_symbol_24, tint_symbol_25);
-        (*(tint_symbol_26)).arr[x_233].arr[x_234] = x_244;
+        (*(tint_symbol_26))[x_233][x_234] = x_244;
         {
           int const x_247 = innerCol_1;
           innerCol_1 = as_type<int>((as_type<uint>(x_247) + as_type<uint>(1)));
@@ -332,7 +325,7 @@
         param_5 = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(x_280) * as_type<uint>(64)))) + as_type<uint>(x_282)));
         param_6 = as_type<int>((as_type<uint>(x_284) + as_type<uint>(x_285)));
         float const x_289 = mm_readB_i1_i1_(&(param_5), &(param_6), tint_symbol_21, tint_symbol_23, tint_symbol_27, tint_symbol_24, tint_symbol_28);
-        (*(tint_symbol_29)).arr[x_278].arr[x_279] = x_289;
+        (*(tint_symbol_29))[x_278][x_279] = x_289;
         {
           int const x_291 = innerCol_2;
           innerCol_2 = as_type<int>((as_type<uint>(x_291) + as_type<uint>(1)));
@@ -362,8 +355,8 @@
         int const x_315 = k;
         int const x_316 = tileCol;
         int const x_317 = inner;
-        float const x_320 = (*(tint_symbol_29)).arr[x_315].arr[as_type<int>((as_type<uint>(x_316) + as_type<uint>(x_317)))];
-        BCached.arr[x_314] = x_320;
+        float const x_320 = (*(tint_symbol_29))[x_315][as_type<int>((as_type<uint>(x_316) + as_type<uint>(x_317)))];
+        BCached[x_314] = x_320;
         {
           int const x_322 = inner;
           inner = as_type<int>((as_type<uint>(x_322) + as_type<uint>(1)));
@@ -379,7 +372,7 @@
         int const x_333 = tileRow;
         int const x_334 = innerRow_3;
         int const x_336 = k;
-        float const x_338 = (*(tint_symbol_26)).arr[as_type<int>((as_type<uint>(x_333) + as_type<uint>(x_334)))].arr[x_336];
+        float const x_338 = (*(tint_symbol_26))[as_type<int>((as_type<uint>(x_333) + as_type<uint>(x_334)))][x_336];
         ACached = x_338;
         innerCol_3 = 0;
         while (true) {
@@ -392,9 +385,9 @@
           int const x_348 = innerCol_3;
           float const x_349 = ACached;
           int const x_350 = innerCol_3;
-          float const x_352 = BCached.arr[x_350];
-          float const x_355 = acc.arr[x_347].arr[x_348];
-          acc.arr[x_347].arr[x_348] = (x_355 + (x_349 * x_352));
+          float const x_352 = BCached[x_350];
+          float const x_355 = acc[x_347][x_348];
+          acc[x_347][x_348] = (x_355 + (x_349 * x_352));
           {
             int const x_358 = innerCol_3;
             innerCol_3 = as_type<int>((as_type<uint>(x_358) + as_type<uint>(1)));
@@ -454,7 +447,7 @@
         int const x_404 = innerCol_4;
         param_7 = as_type<int>((as_type<uint>(x_397) + as_type<uint>(x_398)));
         param_8 = as_type<int>((as_type<uint>(x_400) + as_type<uint>(x_401)));
-        float const x_409 = acc.arr[x_403].arr[x_404];
+        float const x_409 = acc[x_403][x_404];
         param_9 = x_409;
         mm_write_i1_i1_f1_(&(param_7), &(param_8), &(param_9), tint_symbol_24, tint_symbol_21, tint_symbol_30);
       }
@@ -471,7 +464,7 @@
   return;
 }
 
-void main_1(const constant Uniforms* const tint_symbol_31, thread int* const tint_symbol_32, thread int* const tint_symbol_33, thread int* const tint_symbol_34, thread uint3* const tint_symbol_35, thread int* const tint_symbol_36, thread uint3* const tint_symbol_37, const device ssbA* const tint_symbol_38, threadgroup tint_array_wrapper* const tint_symbol_39, const device ssbB* const tint_symbol_40, threadgroup tint_array_wrapper_2* const tint_symbol_41, device ssbOut* const tint_symbol_42) {
+void main_1(const constant Uniforms* const tint_symbol_31, thread int* const tint_symbol_32, thread int* const tint_symbol_33, thread int* const tint_symbol_34, thread uint3* const tint_symbol_35, thread int* const tint_symbol_36, thread uint3* const tint_symbol_37, const device ssbA* const tint_symbol_38, threadgroup tint_array<tint_array<float, 64>, 64>* const tint_symbol_39, const device ssbB* const tint_symbol_40, threadgroup tint_array<tint_array<float, 1>, 64>* const tint_symbol_41, device ssbOut* const tint_symbol_42) {
   int param_18 = 0;
   int param_19 = 0;
   int param_20 = 0;
@@ -493,16 +486,16 @@
   return;
 }
 
-void tint_symbol_1_inner(uint3 gl_LocalInvocationID_param, uint3 gl_GlobalInvocationID_param, uint local_invocation_index, threadgroup tint_array_wrapper_2* const tint_symbol_43, threadgroup tint_array_wrapper* const tint_symbol_44, thread uint3* const tint_symbol_45, thread uint3* const tint_symbol_46, const constant Uniforms* const tint_symbol_47, thread int* const tint_symbol_48, thread int* const tint_symbol_49, thread int* const tint_symbol_50, thread int* const tint_symbol_51, const device ssbA* const tint_symbol_52, const device ssbB* const tint_symbol_53, device ssbOut* const tint_symbol_54) {
+void tint_symbol_1_inner(uint3 gl_LocalInvocationID_param, uint3 gl_GlobalInvocationID_param, uint local_invocation_index, threadgroup tint_array<tint_array<float, 1>, 64>* const tint_symbol_43, threadgroup tint_array<tint_array<float, 64>, 64>* const tint_symbol_44, thread uint3* const tint_symbol_45, thread uint3* const tint_symbol_46, const constant Uniforms* const tint_symbol_47, thread int* const tint_symbol_48, thread int* const tint_symbol_49, thread int* const tint_symbol_50, thread int* const tint_symbol_51, const device ssbA* const tint_symbol_52, const device ssbB* const tint_symbol_53, device ssbOut* const tint_symbol_54) {
   {
     uint const i_1 = local_invocation_index;
     uint const i_2 = (local_invocation_index % 1u);
-    (*(tint_symbol_43)).arr[i_1].arr[i_2] = 0.0f;
+    (*(tint_symbol_43))[i_1][i_2] = 0.0f;
   }
   for(uint idx = local_invocation_index; (idx < 4096u); idx = (idx + 64u)) {
     uint const i = (idx / 64u);
     uint const i_1 = (idx % 64u);
-    (*(tint_symbol_44)).arr[i].arr[i_1] = 0.0f;
+    (*(tint_symbol_44))[i][i_1] = 0.0f;
   }
   threadgroup_barrier(mem_flags::mem_threadgroup);
   *(tint_symbol_45) = gl_LocalInvocationID_param;
@@ -511,8 +504,8 @@
 }
 
 kernel void tint_symbol_1(const constant Uniforms* tint_symbol_59 [[buffer(0)]], const device ssbA* tint_symbol_64 [[buffer(2)]], const device ssbB* tint_symbol_65 [[buffer(3)]], device ssbOut* tint_symbol_66 [[buffer(1)]], uint3 gl_LocalInvocationID_param [[thread_position_in_threadgroup]], uint3 gl_GlobalInvocationID_param [[thread_position_in_grid]], uint local_invocation_index [[thread_index_in_threadgroup]]) {
-  threadgroup tint_array_wrapper_2 tint_symbol_55;
-  threadgroup tint_array_wrapper tint_symbol_56;
+  threadgroup tint_array<tint_array<float, 1>, 64> tint_symbol_55;
+  threadgroup tint_array<tint_array<float, 64>, 64> tint_symbol_56;
   thread uint3 tint_symbol_57 = 0u;
   thread uint3 tint_symbol_58 = 0u;
   thread int tint_symbol_60 = 0;
diff --git a/test/tint/bug/tint/948.wgsl.expected.msl b/test/tint/bug/tint/948.wgsl.expected.msl
index c03a21b..c21d89f 100644
--- a/test/tint/bug/tint/948.wgsl.expected.msl
+++ b/test/tint/bug/tint/948.wgsl.expected.msl
@@ -14,6 +14,18 @@
 
 using namespace metal;
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 template<typename T, int N, int M>
 inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
   return lhs * vec<T, N>(rhs);
@@ -27,7 +39,7 @@
 struct LeftOver {
   /* 0x0000 */ float time;
   /* 0x0004 */ uint padding;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float4x4 worldViewProjection;
   /* 0x0050 */ float2 outputSize;
   /* 0x0058 */ float2 stageSize;
@@ -35,7 +47,7 @@
   /* 0x0068 */ float stageScale;
   /* 0x006c */ float spriteCount;
   /* 0x0070 */ packed_float3 colorMul;
-  /* 0x007c */ int8_t tint_pad_1[4];
+  /* 0x007c */ tint_array<int8_t, 4> tint_pad_1;
 };
 
 float4x4 getFrameData_f1_(thread float* const frameID, const constant LeftOver* const tint_symbol_5, texture2d<float, access::sample> tint_symbol_6, sampler tint_symbol_7) {
diff --git a/test/tint/bug/tint/949.wgsl.expected.msl b/test/tint/bug/tint/949.wgsl.expected.msl
index 5aab1bd..9b8daf4 100644
--- a/test/tint/bug/tint/949.wgsl.expected.msl
+++ b/test/tint/bug/tint/949.wgsl.expected.msl
@@ -14,6 +14,18 @@
 
 using namespace metal;
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 template<typename T, int N, int M>
 inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
   return lhs * vec<T, N>(rhs);
@@ -34,7 +46,7 @@
   /* 0x0040 */ float4x4 u_ViewProjection;
   /* 0x0080 */ float u_bumpStrength;
   /* 0x0084 */ uint padding;
-  /* 0x0088 */ int8_t tint_pad[8];
+  /* 0x0088 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0090 */ packed_float3 u_cameraPosition;
   /* 0x009c */ float u_parallaxScale;
   /* 0x00a0 */ float textureInfoName;
@@ -50,7 +62,7 @@
   /* 0x003c */ uint padding_2;
   /* 0x0040 */ float4 shadowsInfo;
   /* 0x0050 */ float2 depthValues;
-  /* 0x0058 */ int8_t tint_pad_1[8];
+  /* 0x0058 */ tint_array<int8_t, 8> tint_pad_1;
 };
 
 float3x3 cotangent_frame_vf3_vf3_vf2_vf2_(thread float3* const normal_1, thread float3* const p, thread float2* const uv, thread float2* const tangentSpaceParams) {
diff --git a/test/tint/bug/tint/951.spvasm.expected.msl b/test/tint/bug/tint/951.spvasm.expected.msl
index 80a05a7..0e5fdff 100644
--- a/test/tint/bug/tint/951.spvasm.expected.msl
+++ b/test/tint/bug/tint/951.spvasm.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct ssbOut {
-  /* 0x0000 */ float result[1];
+  /* 0x0000 */ tint_array<float, 1> result;
 };
 
 struct ssbA {
-  /* 0x0000 */ float A[1];
+  /* 0x0000 */ tint_array<float, 1> A;
 };
 
 struct Uniforms {
diff --git a/test/tint/bug/tint/977.spvasm.expected.msl b/test/tint/bug/tint/977.spvasm.expected.msl
index 16062d0..83b2b6c 100644
--- a/test/tint/bug/tint/977.spvasm.expected.msl
+++ b/test/tint/bug/tint/977.spvasm.expected.msl
@@ -1,16 +1,29 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct ResultMatrix {
-  /* 0x0000 */ float numbers[1];
+  /* 0x0000 */ tint_array<float, 1> numbers;
 };
 
 struct FirstMatrix {
-  float numbers[1];
+  tint_array<float, 1> numbers;
 };
 
 struct SecondMatrix {
-  float numbers[1];
+  tint_array<float, 1> numbers;
 };
 
 struct Uniforms {
diff --git a/test/tint/bug/tint/993.wgsl.expected.msl b/test/tint/bug/tint/993.wgsl.expected.msl
index 98f5117..7b82d95 100644
--- a/test/tint/bug/tint/993.wgsl.expected.msl
+++ b/test/tint/bug/tint/993.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Constants {
   /* 0x0000 */ uint zero;
 };
@@ -9,16 +22,12 @@
   /* 0x0000 */ uint value;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ atomic_int arr[3];
-};
-
 struct TestData {
-  /* 0x0000 */ tint_array_wrapper data;
+  /* 0x0000 */ tint_array<atomic_int, 3> data;
 };
 
 int runTest(device TestData* const tint_symbol_3, const constant Constants* const tint_symbol_4) {
-  return atomic_load_explicit(&((*(tint_symbol_3)).data.arr[(0u + uint((*(tint_symbol_4)).zero))]), memory_order_relaxed);
+  return atomic_load_explicit(&((*(tint_symbol_3)).data[(0u + uint((*(tint_symbol_4)).zero))]), memory_order_relaxed);
 }
 
 kernel void tint_symbol(device TestData* tint_symbol_5 [[buffer(2)]], const constant Constants* tint_symbol_6 [[buffer(0)]], device Result* tint_symbol_7 [[buffer(1)]]) {
diff --git a/test/tint/bug/tint/998.wgsl.expected.msl b/test/tint/bug/tint/998.wgsl.expected.msl
index 740838e..c9dd773 100644
--- a/test/tint/bug/tint/998.wgsl.expected.msl
+++ b/test/tint/bug/tint/998.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Constants {
   /* 0x0000 */ uint zero;
 };
@@ -9,17 +22,13 @@
   uint value;
 };
 
-struct tint_array_wrapper {
-  uint arr[3];
-};
-
 struct S {
-  tint_array_wrapper data;
+  tint_array<uint, 3> data;
 };
 
 kernel void tint_symbol(const constant Constants* tint_symbol_2 [[buffer(0)]]) {
   thread S tint_symbol_1 = {};
-  tint_symbol_1.data.arr[(*(tint_symbol_2)).zero] = 0u;
+  tint_symbol_1.data[(*(tint_symbol_2)).zero] = 0u;
   return;
 }
 
diff --git a/test/tint/builtins/arrayLength/complex_via_let.wgsl.expected.msl b/test/tint/builtins/arrayLength/complex_via_let.wgsl.expected.msl
index 537a453..f92477a 100644
--- a/test/tint/builtins/arrayLength/complex_via_let.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/complex_via_let.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
-  int a[1];
+  tint_array<int, 1> a;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/complex_via_let_no_struct.wgsl.expected.msl b/test/tint/builtins/arrayLength/complex_via_let_no_struct.wgsl.expected.msl
index 0ab65d1..3fb5295 100644
--- a/test/tint/builtins/arrayLength/complex_via_let_no_struct.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/complex_via_let_no_struct.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/deprecated.wgsl.expected.msl b/test/tint/builtins/arrayLength/deprecated.wgsl.expected.msl
index bf8e5b0..bc4e7ca 100644
--- a/test/tint/builtins/arrayLength/deprecated.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/deprecated.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
-  int a[1];
+  tint_array<int, 1> a;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/simple.wgsl.expected.msl b/test/tint/builtins/arrayLength/simple.wgsl.expected.msl
index 537a453..f92477a 100644
--- a/test/tint/builtins/arrayLength/simple.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/simple.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
-  int a[1];
+  tint_array<int, 1> a;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/simple_no_struct.wgsl.expected.msl b/test/tint/builtins/arrayLength/simple_no_struct.wgsl.expected.msl
index 0ab65d1..3fb5295 100644
--- a/test/tint/builtins/arrayLength/simple_no_struct.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/simple_no_struct.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/via_let.wgsl.expected.msl b/test/tint/builtins/arrayLength/via_let.wgsl.expected.msl
index 537a453..f92477a 100644
--- a/test/tint/builtins/arrayLength/via_let.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/via_let.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
-  int a[1];
+  tint_array<int, 1> a;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/via_let_complex.wgsl.expected.msl b/test/tint/builtins/arrayLength/via_let_complex.wgsl.expected.msl
index 537a453..f92477a 100644
--- a/test/tint/builtins/arrayLength/via_let_complex.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/via_let_complex.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct S {
-  int a[1];
+  tint_array<int, 1> a;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/via_let_complex_no_struct.wgsl.expected.msl b/test/tint/builtins/arrayLength/via_let_complex_no_struct.wgsl.expected.msl
index 0ab65d1..3fb5295 100644
--- a/test/tint/builtins/arrayLength/via_let_complex_no_struct.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/via_let_complex_no_struct.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/arrayLength/via_let_no_struct.wgsl.expected.msl b/test/tint/builtins/arrayLength/via_let_no_struct.wgsl.expected.msl
index 0ab65d1..3fb5295 100644
--- a/test/tint/builtins/arrayLength/via_let_no_struct.wgsl.expected.msl
+++ b/test/tint/builtins/arrayLength/via_let_no_struct.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 kernel void tint_symbol(const constant tint_symbol_1* tint_symbol_3 [[buffer(30)]]) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/1588cd.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/1588cd.wgsl.expected.msl
index 1f8ac29..8f9b209 100644
--- a/test/tint/builtins/gen/literal/arrayLength/1588cd.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/1588cd.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  int arg_0[1];
+  tint_array<int, 1> arg_0;
 };
 
 void arrayLength_1588cd(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/61b1c7.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/61b1c7.wgsl.expected.msl
index 9fa02f3..a0b7187 100644
--- a/test/tint/builtins/gen/literal/arrayLength/61b1c7.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/61b1c7.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  int arg_0[1];
+  tint_array<int, 1> arg_0;
 };
 
 void arrayLength_61b1c7(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/a0f5ca.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/a0f5ca.wgsl.expected.msl
index f1b7785..b0aba71 100644
--- a/test/tint/builtins/gen/literal/arrayLength/a0f5ca.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/a0f5ca.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  float arg_0[1];
+  tint_array<float, 1> arg_0;
 };
 
 void arrayLength_a0f5ca(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/cdd123.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/cdd123.wgsl.expected.msl
index 22cfa6c..b7fe50b 100644
--- a/test/tint/builtins/gen/literal/arrayLength/cdd123.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/cdd123.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  float arg_0[1];
+  tint_array<float, 1> arg_0;
 };
 
 void arrayLength_cdd123(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/cfca0a.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/cfca0a.wgsl.expected.msl
index d64c1e0..f62106e 100644
--- a/test/tint/builtins/gen/literal/arrayLength/cfca0a.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/cfca0a.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  uint arg_0[1];
+  tint_array<uint, 1> arg_0;
 };
 
 void arrayLength_cfca0a(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/arrayLength/eb510f.wgsl.expected.msl b/test/tint/builtins/gen/literal/arrayLength/eb510f.wgsl.expected.msl
index 4412853..05c3bc9 100644
--- a/test/tint/builtins/gen/literal/arrayLength/eb510f.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/arrayLength/eb510f.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  uint arg_0[1];
+  tint_array<uint, 1> arg_0;
 };
 
 void arrayLength_eb510f(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/literal/textureLoad/8acf41.wgsl.expected.msl b/test/tint/builtins/gen/literal/textureLoad/8acf41.wgsl.expected.msl
index 04f882d..617b8df 100644
--- a/test/tint/builtins/gen/literal/textureLoad/8acf41.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/textureLoad/8acf41.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct GammaTransferParams {
   /* 0x0000 */ float G;
   /* 0x0004 */ float A;
@@ -15,7 +28,7 @@
 struct ExternalTextureParams {
   /* 0x0000 */ uint numPlanes;
   /* 0x0004 */ uint doYuvToRgbConversionOnly;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float3x4 yuvToRgbConversionMatrix;
   /* 0x0040 */ GammaTransferParams gammaDecodeParams;
   /* 0x0060 */ GammaTransferParams gammaEncodeParams;
diff --git a/test/tint/builtins/gen/literal/textureSampleLevel/979816.wgsl.expected.msl b/test/tint/builtins/gen/literal/textureSampleLevel/979816.wgsl.expected.msl
index fa5b6c3..5b65152 100644
--- a/test/tint/builtins/gen/literal/textureSampleLevel/979816.wgsl.expected.msl
+++ b/test/tint/builtins/gen/literal/textureSampleLevel/979816.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct GammaTransferParams {
   /* 0x0000 */ float G;
   /* 0x0004 */ float A;
@@ -15,7 +28,7 @@
 struct ExternalTextureParams {
   /* 0x0000 */ uint numPlanes;
   /* 0x0004 */ uint doYuvToRgbConversionOnly;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float3x4 yuvToRgbConversionMatrix;
   /* 0x0040 */ GammaTransferParams gammaDecodeParams;
   /* 0x0060 */ GammaTransferParams gammaEncodeParams;
diff --git a/test/tint/builtins/gen/var/arrayLength/1588cd.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/1588cd.wgsl.expected.msl
index 1f8ac29..8f9b209 100644
--- a/test/tint/builtins/gen/var/arrayLength/1588cd.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/1588cd.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  int arg_0[1];
+  tint_array<int, 1> arg_0;
 };
 
 void arrayLength_1588cd(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/arrayLength/61b1c7.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/61b1c7.wgsl.expected.msl
index 9fa02f3..a0b7187 100644
--- a/test/tint/builtins/gen/var/arrayLength/61b1c7.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/61b1c7.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  int arg_0[1];
+  tint_array<int, 1> arg_0;
 };
 
 void arrayLength_61b1c7(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/arrayLength/a0f5ca.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/a0f5ca.wgsl.expected.msl
index f1b7785..b0aba71 100644
--- a/test/tint/builtins/gen/var/arrayLength/a0f5ca.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/a0f5ca.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  float arg_0[1];
+  tint_array<float, 1> arg_0;
 };
 
 void arrayLength_a0f5ca(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/arrayLength/cdd123.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/cdd123.wgsl.expected.msl
index 22cfa6c..b7fe50b 100644
--- a/test/tint/builtins/gen/var/arrayLength/cdd123.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/cdd123.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  float arg_0[1];
+  tint_array<float, 1> arg_0;
 };
 
 void arrayLength_cdd123(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/arrayLength/cfca0a.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/cfca0a.wgsl.expected.msl
index d64c1e0..f62106e 100644
--- a/test/tint/builtins/gen/var/arrayLength/cfca0a.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/cfca0a.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RO {
-  uint arg_0[1];
+  tint_array<uint, 1> arg_0;
 };
 
 void arrayLength_cfca0a(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/arrayLength/eb510f.wgsl.expected.msl b/test/tint/builtins/gen/var/arrayLength/eb510f.wgsl.expected.msl
index 4412853..05c3bc9 100644
--- a/test/tint/builtins/gen/var/arrayLength/eb510f.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/arrayLength/eb510f.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
-  /* 0x0000 */ uint4 buffer_size[1];
+  /* 0x0000 */ tint_array<uint4, 1> buffer_size;
 };
 
 struct SB_RW {
-  uint arg_0[1];
+  tint_array<uint, 1> arg_0;
 };
 
 void arrayLength_eb510f(const constant tint_symbol_1* const tint_symbol_3) {
diff --git a/test/tint/builtins/gen/var/textureLoad/8acf41.wgsl.expected.msl b/test/tint/builtins/gen/var/textureLoad/8acf41.wgsl.expected.msl
index 5f8b2c3..d6fff77 100644
--- a/test/tint/builtins/gen/var/textureLoad/8acf41.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/textureLoad/8acf41.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct GammaTransferParams {
   /* 0x0000 */ float G;
   /* 0x0004 */ float A;
@@ -15,7 +28,7 @@
 struct ExternalTextureParams {
   /* 0x0000 */ uint numPlanes;
   /* 0x0004 */ uint doYuvToRgbConversionOnly;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float3x4 yuvToRgbConversionMatrix;
   /* 0x0040 */ GammaTransferParams gammaDecodeParams;
   /* 0x0060 */ GammaTransferParams gammaEncodeParams;
diff --git a/test/tint/builtins/gen/var/textureSampleLevel/979816.wgsl.expected.msl b/test/tint/builtins/gen/var/textureSampleLevel/979816.wgsl.expected.msl
index a84758c..9622213 100644
--- a/test/tint/builtins/gen/var/textureSampleLevel/979816.wgsl.expected.msl
+++ b/test/tint/builtins/gen/var/textureSampleLevel/979816.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct GammaTransferParams {
   /* 0x0000 */ float G;
   /* 0x0004 */ float A;
@@ -15,7 +28,7 @@
 struct ExternalTextureParams {
   /* 0x0000 */ uint numPlanes;
   /* 0x0004 */ uint doYuvToRgbConversionOnly;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float3x4 yuvToRgbConversionMatrix;
   /* 0x0040 */ GammaTransferParams gammaDecodeParams;
   /* 0x0060 */ GammaTransferParams gammaEncodeParams;
diff --git a/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.msl b/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.msl
index a7d71cc..2afc801 100644
--- a/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.msl
+++ b/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct GammaTransferParams {
   /* 0x0000 */ float G;
   /* 0x0004 */ float A;
@@ -15,7 +28,7 @@
 struct ExternalTextureParams {
   /* 0x0000 */ uint numPlanes;
   /* 0x0004 */ uint doYuvToRgbConversionOnly;
-  /* 0x0008 */ int8_t tint_pad[8];
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0010 */ float3x4 yuvToRgbConversionMatrix;
   /* 0x0040 */ GammaTransferParams gammaDecodeParams;
   /* 0x0060 */ GammaTransferParams gammaEncodeParams;
diff --git a/test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl b/test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl
index 31add65..e210c3c 100644
--- a/test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl
@@ -2,6 +2,18 @@
 
 using namespace metal;
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 template<typename T, int N, int M>
 inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
   return lhs * vec<T, N>(rhs);
@@ -14,9 +26,9 @@
 
 struct S {
   /* 0x0000 */ float3x2 tint_symbol;
-  /* 0x0018 */ int8_t tint_pad[8];
+  /* 0x0018 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0020 */ packed_float3 vector;
-  /* 0x002c */ int8_t tint_pad_1[4];
+  /* 0x002c */ tint_array<int8_t, 4> tint_pad_1;
 };
 
 fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl b/test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl
index 40ec533..8f4ff55 100644
--- a/test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl
@@ -12,10 +12,22 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ float3x3 tint_symbol;
   /* 0x0030 */ packed_float3 vector;
-  /* 0x003c */ int8_t tint_pad[4];
+  /* 0x003c */ tint_array<int8_t, 4> tint_pad;
 };
 
 fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl b/test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl
index a5da864..d9fc80b 100644
--- a/test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl
@@ -12,10 +12,22 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ float3x3 tint_symbol;
   /* 0x0030 */ packed_float3 vector;
-  /* 0x003c */ int8_t tint_pad[4];
+  /* 0x003c */ tint_array<int8_t, 4> tint_pad;
 };
 
 fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl b/test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl
index 36412ba..3f66659 100644
--- a/test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl
@@ -12,10 +12,22 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ float4x3 tint_symbol;
   /* 0x0040 */ packed_float3 vector;
-  /* 0x004c */ int8_t tint_pad[4];
+  /* 0x004c */ tint_array<int8_t, 4> tint_pad;
 };
 
 fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/expressions/index/let/let/literal/array.wgsl.expected.msl b/test/tint/expressions/index/let/let/literal/array.wgsl.expected.msl
index 6a9487f..c5f5865 100644
--- a/test/tint/expressions/index/let/let/literal/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/let/let/literal/array.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f() {
-  tint_array_wrapper const a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
+  tint_array<int, 8> const a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
   int const i = 1;
-  return a.arr[1];
+  return 2;
 }
 
diff --git a/test/tint/expressions/index/let/let/param/array.wgsl.expected.msl b/test/tint/expressions/index/let/let/param/array.wgsl.expected.msl
index 7b941e4..11906e9 100644
--- a/test/tint/expressions/index/let/let/param/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/let/let/param/array.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f(int x) {
-  tint_array_wrapper const a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
+  tint_array<int, 8> const a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
   int const i = x;
-  return a.arr[i];
+  return a[i];
 }
 
diff --git a/test/tint/expressions/index/let/literal/array.wgsl.expected.msl b/test/tint/expressions/index/let/literal/array.wgsl.expected.msl
index d4d28b1..e0a4066 100644
--- a/test/tint/expressions/index/let/literal/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/let/literal/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f() {
-  tint_array_wrapper const a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
-  return a.arr[1];
+  tint_array<int, 8> const a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
+  return 2;
 }
 
diff --git a/test/tint/expressions/index/let/param/array.wgsl.expected.msl b/test/tint/expressions/index/let/param/array.wgsl.expected.msl
index eac5c42..d3bbdae 100644
--- a/test/tint/expressions/index/let/param/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/let/param/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f(int i) {
-  tint_array_wrapper const a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
-  return a.arr[i];
+  tint_array<int, 8> const a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
+  return a[i];
 }
 
diff --git a/test/tint/expressions/index/let/var/literal/array.wgsl.expected.msl b/test/tint/expressions/index/let/var/literal/array.wgsl.expected.msl
index 30f40e9..74fc40d 100644
--- a/test/tint/expressions/index/let/var/literal/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/let/var/literal/array.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f() {
-  tint_array_wrapper a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
+  tint_array<int, 8> a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
   int const i = 1;
-  return a.arr[1];
+  return a[1];
 }
 
diff --git a/test/tint/expressions/index/var/let/literal/array.wgsl.expected.msl b/test/tint/expressions/index/var/let/literal/array.wgsl.expected.msl
index 30f40e9..74fc40d 100644
--- a/test/tint/expressions/index/var/let/literal/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/var/let/literal/array.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f() {
-  tint_array_wrapper a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
+  tint_array<int, 8> a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
   int const i = 1;
-  return a.arr[1];
+  return a[1];
 }
 
diff --git a/test/tint/expressions/index/var/let/param/array.wgsl.expected.msl b/test/tint/expressions/index/var/let/param/array.wgsl.expected.msl
index b1e207d..970f617 100644
--- a/test/tint/expressions/index/var/let/param/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/var/let/param/array.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f(int x) {
-  tint_array_wrapper a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
+  tint_array<int, 8> a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
   int const i = x;
-  return a.arr[i];
+  return a[i];
 }
 
diff --git a/test/tint/expressions/index/var/literal/array.wgsl.expected.msl b/test/tint/expressions/index/var/literal/array.wgsl.expected.msl
index ae2d9ca..5cc2f07 100644
--- a/test/tint/expressions/index/var/literal/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/var/literal/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f() {
-  tint_array_wrapper a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
-  return a.arr[1];
+  tint_array<int, 8> a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
+  return a[1];
 }
 
diff --git a/test/tint/expressions/index/var/param/array.wgsl.expected.msl b/test/tint/expressions/index/var/param/array.wgsl.expected.msl
index 9d03b80..918a63b 100644
--- a/test/tint/expressions/index/var/param/array.wgsl.expected.msl
+++ b/test/tint/expressions/index/var/param/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 int f(int i) {
-  tint_array_wrapper a = {.arr={1, 2, 3, 4, 5, 6, 7, 8}};
-  return a.arr[i];
+  tint_array<int, 8> a = tint_array<int, 8>{1, 2, 3, 4, 5, 6, 7, 8};
+  return a[i];
 }
 
diff --git a/test/tint/expressions/swizzle/read/packed_vec3/f32.wgsl.expected.msl b/test/tint/expressions/swizzle/read/packed_vec3/f32.wgsl.expected.msl
index 9f40be1..e2bbca3 100644
--- a/test/tint/expressions/swizzle/read/packed_vec3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/read/packed_vec3/f32.wgsl.expected.msl
@@ -12,9 +12,21 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_float3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(const constant S* const tint_symbol) {
diff --git a/test/tint/expressions/swizzle/read/packed_vec3/i32.wgsl.expected.msl b/test/tint/expressions/swizzle/read/packed_vec3/i32.wgsl.expected.msl
index d396d1f..7a93a59 100644
--- a/test/tint/expressions/swizzle/read/packed_vec3/i32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/read/packed_vec3/i32.wgsl.expected.msl
@@ -1,9 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_int3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(const constant S* const tint_symbol) {
diff --git a/test/tint/expressions/swizzle/read/packed_vec3/u32.wgsl.expected.msl b/test/tint/expressions/swizzle/read/packed_vec3/u32.wgsl.expected.msl
index 8f6a4a6..7444f75 100644
--- a/test/tint/expressions/swizzle/read/packed_vec3/u32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/read/packed_vec3/u32.wgsl.expected.msl
@@ -1,9 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_uint3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(const constant S* const tint_symbol) {
diff --git a/test/tint/expressions/swizzle/write/packed_vec3/f32.wgsl.expected.msl b/test/tint/expressions/swizzle/write/packed_vec3/f32.wgsl.expected.msl
index 2e63ec7..7599cbc 100644
--- a/test/tint/expressions/swizzle/write/packed_vec3/f32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/write/packed_vec3/f32.wgsl.expected.msl
@@ -12,9 +12,21 @@
   return vec<T, M>(lhs) * rhs;
 }
 
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_float3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(device S* const tint_symbol) {
diff --git a/test/tint/expressions/swizzle/write/packed_vec3/i32.wgsl.expected.msl b/test/tint/expressions/swizzle/write/packed_vec3/i32.wgsl.expected.msl
index 2bcecc1..06cb457 100644
--- a/test/tint/expressions/swizzle/write/packed_vec3/i32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/write/packed_vec3/i32.wgsl.expected.msl
@@ -1,9 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_int3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(device S* const tint_symbol) {
diff --git a/test/tint/expressions/swizzle/write/packed_vec3/u32.wgsl.expected.msl b/test/tint/expressions/swizzle/write/packed_vec3/u32.wgsl.expected.msl
index b55912d..e8e4904 100644
--- a/test/tint/expressions/swizzle/write/packed_vec3/u32.wgsl.expected.msl
+++ b/test/tint/expressions/swizzle/write/packed_vec3/u32.wgsl.expected.msl
@@ -1,9 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ packed_uint3 v;
-  /* 0x000c */ int8_t tint_pad[4];
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
 void f(device S* const tint_symbol) {
diff --git a/test/tint/expressions/zero_init/array/bool.wgsl.expected.msl b/test/tint/expressions/zero_init/array/bool.wgsl.expected.msl
index ead82c7..8b8b451 100644
--- a/test/tint/expressions/zero_init/array/bool.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/array/bool.wgsl.expected.msl
@@ -1,11 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  bool arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
-  tint_array_wrapper v = {.arr={}};
+  tint_array<bool, 4> v = tint_array<bool, 4>{};
 }
 
diff --git a/test/tint/expressions/zero_init/array/f32.wgsl.expected.msl b/test/tint/expressions/zero_init/array/f32.wgsl.expected.msl
index 7a8df6c..60e142d 100644
--- a/test/tint/expressions/zero_init/array/f32.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/array/f32.wgsl.expected.msl
@@ -1,11 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
-  tint_array_wrapper v = {.arr={}};
+  tint_array<float, 4> v = tint_array<float, 4>{};
 }
 
diff --git a/test/tint/expressions/zero_init/array/i32.wgsl.expected.msl b/test/tint/expressions/zero_init/array/i32.wgsl.expected.msl
index e8cd266..42ecab7 100644
--- a/test/tint/expressions/zero_init/array/i32.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/array/i32.wgsl.expected.msl
@@ -1,11 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
-  tint_array_wrapper v = {.arr={}};
+  tint_array<int, 4> v = tint_array<int, 4>{};
 }
 
diff --git a/test/tint/expressions/zero_init/array/struct.wgsl.expected.msl b/test/tint/expressions/zero_init/array/struct.wgsl.expected.msl
index 79d7fd7..5101891 100644
--- a/test/tint/expressions/zero_init/array/struct.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/array/struct.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   int i;
   uint u;
@@ -8,11 +21,7 @@
   bool b;
 };
 
-struct tint_array_wrapper {
-  S arr[4];
-};
-
 void f() {
-  tint_array_wrapper v = {.arr={}};
+  tint_array<S, 4> v = tint_array<S, 4>{};
 }
 
diff --git a/test/tint/expressions/zero_init/array/u32.wgsl.expected.msl b/test/tint/expressions/zero_init/array/u32.wgsl.expected.msl
index 83dceb0..b2f7135 100644
--- a/test/tint/expressions/zero_init/array/u32.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/array/u32.wgsl.expected.msl
@@ -1,11 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  uint arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
-  tint_array_wrapper v = {.arr={}};
+  tint_array<uint, 4> v = tint_array<uint, 4>{};
 }
 
diff --git a/test/tint/expressions/zero_init/struct/array.wgsl.expected.msl b/test/tint/expressions/zero_init/struct/array.wgsl.expected.msl
index 2600536..ec53d10 100644
--- a/test/tint/expressions/zero_init/struct/array.wgsl.expected.msl
+++ b/test/tint/expressions/zero_init/struct/array.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  tint_array_wrapper a;
+  tint_array<float, 4> a;
 };
 
 void f() {
diff --git a/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.msl b/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.msl
index abb676b..860459d 100644
--- a/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.msl
+++ b/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.msl
@@ -1,33 +1,42 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct strided_arr {
-  /* 0x0000 */ float2 el;
-  /* 0x0008 */ int8_t tint_pad[8];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ strided_arr arr[2];
+struct strided_arr {
+  /* 0x0000 */ float2 el;
+  /* 0x0008 */ tint_array<int8_t, 8> tint_pad;
 };
 
 struct SSBO {
-  /* 0x0000 */ tint_array_wrapper m;
+  /* 0x0000 */ tint_array<strided_arr, 2> m;
 };
 
-float2x2 arr_to_mat2x2_stride_16(tint_array_wrapper arr) {
-  return float2x2(arr.arr[0u].el, arr.arr[1u].el);
+float2x2 arr_to_mat2x2_stride_16(tint_array<strided_arr, 2> arr) {
+  return float2x2(arr[0u].el, arr[1u].el);
 }
 
-tint_array_wrapper mat2x2_stride_16_to_arr(float2x2 m) {
+tint_array<strided_arr, 2> mat2x2_stride_16_to_arr(float2x2 m) {
   strided_arr const tint_symbol_1 = {.el=m[0u]};
   strided_arr const tint_symbol_2 = {.el=m[1u]};
-  tint_array_wrapper const tint_symbol_3 = {.arr={tint_symbol_1, tint_symbol_2}};
+  tint_array<strided_arr, 2> const tint_symbol_3 = tint_array<strided_arr, 2>{tint_symbol_1, tint_symbol_2};
   return tint_symbol_3;
 }
 
 void f_1(device SSBO* const tint_symbol_4) {
   float2x2 const x_15 = arr_to_mat2x2_stride_16((*(tint_symbol_4)).m);
-  tint_array_wrapper const tint_symbol = mat2x2_stride_16_to_arr(x_15);
+  tint_array<strided_arr, 2> const tint_symbol = mat2x2_stride_16_to_arr(x_15);
   (*(tint_symbol_4)).m = tint_symbol;
   return;
 }
diff --git a/test/tint/let/global/global.wgsl.expected.msl b/test/tint/let/global/global.wgsl.expected.msl
index 72d5df7..d4ded52 100644
--- a/test/tint/let/global/global.wgsl.expected.msl
+++ b/test/tint/let/global/global.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct MyStruct {
-  float f1;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[10];
+struct MyStruct {
+  float f1;
 };
 
 constant int v1 = 1;
@@ -25,7 +34,7 @@
 
 constant MyStruct v8 = {};
 
-constant tint_array_wrapper v9 = {.arr={}};
+constant tint_array<float, 10> v9 = tint_array<float, 10>{};
 
 struct tint_symbol_1 {
   float4 value [[color(0)]];
diff --git a/test/tint/let/inferred/function.wgsl.expected.msl b/test/tint/let/inferred/function.wgsl.expected.msl
index 9d93fcf..604c979 100644
--- a/test/tint/let/inferred/function.wgsl.expected.msl
+++ b/test/tint/let/inferred/function.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct MyStruct {
-  float f1;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[10];
+struct MyStruct {
+  float f1;
 };
 
 int ret_i32() {
@@ -26,8 +35,8 @@
   return tint_symbol_2;
 }
 
-tint_array_wrapper ret_MyArray() {
-  tint_array_wrapper const tint_symbol_3 = {.arr={}};
+tint_array<float, 10> ret_MyArray() {
+  tint_array<float, 10> const tint_symbol_3 = tint_array<float, 10>{};
   return tint_symbol_3;
 }
 
@@ -40,13 +49,13 @@
   float3 const v6 = float3(1.0f);
   float3x3 const v7 = float3x3(float3(1.0f), float3(1.0f), float3(1.0f));
   MyStruct const v8 = {.f1=1.0f};
-  tint_array_wrapper const v9 = {.arr={}};
+  tint_array<float, 10> const v9 = tint_array<float, 10>{};
   int const v10 = ret_i32();
   uint const v11 = ret_u32();
   float const v12 = ret_f32();
   MyStruct const v13 = ret_MyStruct();
   MyStruct const v14 = ret_MyStruct();
-  tint_array_wrapper const v15 = ret_MyArray();
+  tint_array<float, 10> const v15 = ret_MyArray();
 }
 
 struct tint_symbol_1 {
diff --git a/test/tint/out_of_order_decls/array/alias.wgsl.expected.msl b/test/tint/out_of_order_decls/array/alias.wgsl.expected.msl
index e345a6d..3baeea6 100644
--- a/test/tint/out_of_order_decls/array/alias.wgsl.expected.msl
+++ b/test/tint/out_of_order_decls/array/alias.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 fragment void f() {
-  thread tint_array_wrapper tint_symbol = {};
-  tint_symbol.arr[0] = 1;
+  thread tint_array<int, 4> tint_symbol = {};
+  tint_symbol[0] = 1;
   return;
 }
 
diff --git a/test/tint/out_of_order_decls/array/struct.wgsl.expected.msl b/test/tint/out_of_order_decls/array/struct.wgsl.expected.msl
index 4e91e2e..98b6893 100644
--- a/test/tint/out_of_order_decls/array/struct.wgsl.expected.msl
+++ b/test/tint/out_of_order_decls/array/struct.wgsl.expected.msl
@@ -1,18 +1,27 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   int m;
 };
 
-struct tint_array_wrapper {
-  S arr[4];
-};
-
 fragment void f() {
-  thread tint_array_wrapper tint_symbol_1 = {};
+  thread tint_array<S, 4> tint_symbol_1 = {};
   S const tint_symbol = {.m=1};
-  tint_symbol_1.arr[0] = tint_symbol;
+  tint_symbol_1[0] = tint_symbol;
   return;
 }
 
diff --git a/test/tint/samples/compute_boids.wgsl.expected.msl b/test/tint/samples/compute_boids.wgsl.expected.msl
index cf438ab..a3cb32a 100644
--- a/test/tint/samples/compute_boids.wgsl.expected.msl
+++ b/test/tint/samples/compute_boids.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct tint_symbol_1 {
   float2 a_particlePos [[attribute(0)]];
   float2 a_particleVel [[attribute(1)]];
@@ -54,12 +67,8 @@
   /* 0x0018 */ float rule3Scale;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ Particle arr[5];
-};
-
 struct Particles {
-  /* 0x0000 */ tint_array_wrapper particles;
+  /* 0x0000 */ tint_array<Particle, 5> particles;
 };
 
 void comp_main_inner(uint3 gl_GlobalInvocationID, device Particles* const tint_symbol_4, const constant SimParams* const tint_symbol_5, device Particles* const tint_symbol_6) {
@@ -67,8 +76,8 @@
   if ((index >= 5u)) {
     return;
   }
-  float2 vPos = (*(tint_symbol_4)).particles.arr[index].pos;
-  float2 vVel = (*(tint_symbol_4)).particles.arr[index].vel;
+  float2 vPos = (*(tint_symbol_4)).particles[index].pos;
+  float2 vVel = (*(tint_symbol_4)).particles[index].vel;
   float2 cMass = float2(0.0f);
   float2 cVel = float2(0.0f);
   float2 colVel = float2(0.0f);
@@ -80,8 +89,8 @@
     if ((i == index)) {
       continue;
     }
-    pos = float2((*(tint_symbol_4)).particles.arr[i].pos).xy;
-    vel = float2((*(tint_symbol_4)).particles.arr[i].vel).xy;
+    pos = float2((*(tint_symbol_4)).particles[i].pos).xy;
+    vel = float2((*(tint_symbol_4)).particles[i].vel).xy;
     if ((distance(pos, vPos) < (*(tint_symbol_5)).rule1Distance)) {
       cMass = (cMass + pos);
       cMassCount = as_type<int>((as_type<uint>(cMassCount) + as_type<uint>(1)));
@@ -115,8 +124,8 @@
   if ((vPos[1] > 1.0f)) {
     vPos[1] = -1.0f;
   }
-  (*(tint_symbol_6)).particles.arr[index].pos = vPos;
-  (*(tint_symbol_6)).particles.arr[index].vel = vVel;
+  (*(tint_symbol_6)).particles[index].pos = vPos;
+  (*(tint_symbol_6)).particles[index].vel = vVel;
 }
 
 kernel void comp_main(device Particles* tint_symbol_7 [[buffer(1)]], const constant SimParams* tint_symbol_8 [[buffer(0)]], device Particles* tint_symbol_9 [[buffer(2)]], uint3 gl_GlobalInvocationID [[thread_position_in_grid]]) {
diff --git a/test/tint/samples/triangle.wgsl.expected.msl b/test/tint/samples/triangle.wgsl.expected.msl
index 51fb847..664ec4e 100644
--- a/test/tint/samples/triangle.wgsl.expected.msl
+++ b/test/tint/samples/triangle.wgsl.expected.msl
@@ -1,18 +1,27 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  float2 arr[3];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-constant tint_array_wrapper pos = {.arr={float2(0.0f, 0.5f), float2(-0.5f), float2(0.5f, -0.5f)}};
+constant tint_array<float2, 3> pos = tint_array<float2, 3>{float2(0.0f, 0.5f), float2(-0.5f), float2(0.5f, -0.5f)};
 
 struct tint_symbol {
   float4 value [[position]];
 };
 
 float4 vtx_main_inner(uint VertexIndex) {
-  return float4(pos.arr[VertexIndex], 0.0f, 1.0f);
+  return float4(pos[VertexIndex], 0.0f, 1.0f);
 }
 
 vertex tint_symbol vtx_main(uint VertexIndex [[vertex_id]]) {
diff --git a/test/tint/shader_io/shared_struct_storage_buffer.wgsl.expected.msl b/test/tint/shader_io/shared_struct_storage_buffer.wgsl.expected.msl
index 7b765f6..b086e52 100644
--- a/test/tint/shader_io/shared_struct_storage_buffer.wgsl.expected.msl
+++ b/test/tint/shader_io/shared_struct_storage_buffer.wgsl.expected.msl
@@ -1,12 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   /* 0x0000 */ float f;
   /* 0x0004 */ uint u;
-  /* 0x0008 */ int8_t tint_pad[120];
+  /* 0x0008 */ tint_array<int8_t, 120> tint_pad;
   /* 0x0080 */ float4 v;
-  /* 0x0090 */ int8_t tint_pad_1[112];
+  /* 0x0090 */ tint_array<int8_t, 112> tint_pad_1;
 };
 
 struct tint_symbol_1 {
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.msl
index acf0cc6..939ff14 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,19 +22,15 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
   for(int i = 0; (i < 4); i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)))) {
-    s1.a1.arr[(*(tint_symbol_1)).i] = v;
+    s1.a1[(*(tint_symbol_1)).i] = v;
   }
   return;
 }
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.msl
index 60c282a..76e27e9 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,18 +22,14 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  for(int i = 0; (i < 4); s1.a1.arr[(*(tint_symbol_1)).i] = v) {
+  for(int i = 0; (i < 4); s1.a1[(*(tint_symbol_1)).i] = v) {
     i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)));
   }
   return;
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.msl
index 8f33141..82e2101 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,19 +22,15 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
   int i = 0;
-  for(s1.a1.arr[(*(tint_symbol_1)).i] = v; (i < 4); i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)))) {
+  for(s1.a1[(*(tint_symbol_1)).i] = v; (i < 4); i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)))) {
   }
   return;
 }
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.msl
index 7652337..76c3cca 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
   /* 0x0004 */ uint j;
@@ -10,20 +23,12 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct S1 {
-  tint_array_wrapper a2;
-};
-
-struct tint_array_wrapper_1 {
-  S1 arr[8];
+  tint_array<InnerS, 8> a2;
 };
 
 struct OuterS {
-  tint_array_wrapper_1 a1;
+  tint_array<S1, 8> a1;
 };
 
 uint getNextIndex(thread uint* const tint_symbol_3) {
@@ -37,7 +42,7 @@
   OuterS s = {};
   InnerS const tint_symbol_1 = v;
   uint const tint_symbol_2 = getNextIndex(&(tint_symbol_4));
-  s.a1.arr[tint_symbol_2].a2.arr[(*(tint_symbol_5)).j] = tint_symbol_1;
+  s.a1[tint_symbol_2].a2[(*(tint_symbol_5)).j] = tint_symbol_1;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.msl
index 17a3a5e..6e93e31 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,18 +22,14 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  s1.a1.arr[(*(tint_symbol_1)).i] = v;
+  s1.a1[(*(tint_symbol_1)).i] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.msl
index 12691cd..05ae52c 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
   /* 0x0004 */ uint j;
@@ -10,22 +23,14 @@
   int v;
 };
 
-struct tint_array_wrapper_1 {
-  InnerS arr[8];
-};
-
-struct tint_array_wrapper {
-  tint_array_wrapper_1 arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<tint_array<InnerS, 8>, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  s1.a1.arr[(*(tint_symbol_1)).i].arr[(*(tint_symbol_1)).j] = v;
+  s1.a1[(*(tint_symbol_1)).i][(*(tint_symbol_1)).j] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.msl
index 7686939..9ad4660 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -13,18 +26,14 @@
   InnerS s2;
 };
 
-struct tint_array_wrapper {
-  S1 arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<S1, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  s1.a1.arr[(*(tint_symbol_1)).i].s2 = v;
+  s1.a1[(*(tint_symbol_1)).i].s2 = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.msl
index a638c3f..c92d7c4 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
   /* 0x0004 */ uint j;
@@ -10,26 +23,18 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct S1 {
-  tint_array_wrapper a2;
-};
-
-struct tint_array_wrapper_1 {
-  S1 arr[8];
+  tint_array<InnerS, 8> a2;
 };
 
 struct OuterS {
-  tint_array_wrapper_1 a1;
+  tint_array<S1, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s = {};
-  s.a1.arr[(*(tint_symbol_1)).i].a2.arr[(*(tint_symbol_1)).j] = v;
+  s.a1[(*(tint_symbol_1)).i].a2[(*(tint_symbol_1)).j] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.msl
index 6d0fc32..ac9d29d 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -10,7 +23,7 @@
 };
 
 struct OuterS {
-  /* 0x0000 */ InnerS a1[1];
+  /* 0x0000 */ tint_array<InnerS, 1> a1;
 };
 
 kernel void tint_symbol(device OuterS* tint_symbol_1 [[buffer(1)]], const constant Uniforms* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.msl
index 2b23084..b9abd21 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
   /* 0x0004 */ uint j;
@@ -10,21 +23,17 @@
   /* 0x0000 */ int v;
 };
 
-struct tint_array_wrapper {
-  /* 0x0000 */ InnerS arr[8];
-};
-
 struct S1 {
-  /* 0x0000 */ tint_array_wrapper a2;
+  /* 0x0000 */ tint_array<InnerS, 8> a2;
 };
 
 struct OuterS {
-  /* 0x0000 */ S1 a1[1];
+  /* 0x0000 */ tint_array<S1, 1> a1;
 };
 
 kernel void tint_symbol(device OuterS* tint_symbol_1 [[buffer(1)]], const constant Uniforms* tint_symbol_2 [[buffer(0)]]) {
   InnerS v = {};
-  (*(tint_symbol_1)).a1[(*(tint_symbol_2)).i].a2.arr[(*(tint_symbol_2)).j] = v;
+  (*(tint_symbol_1)).a1[(*(tint_symbol_2)).i].a2[(*(tint_symbol_2)).j] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.msl
index 3a268a0..6bdd4e5 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,20 +22,16 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
-  tint_array_wrapper a2;
+  tint_array<InnerS, 8> a1;
+  tint_array<InnerS, 8> a2;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  s1.a1.arr[(*(tint_symbol_1)).i] = v;
-  s1.a2.arr[(*(tint_symbol_1)).i] = v;
+  s1.a1[(*(tint_symbol_1)).i] = v;
+  s1.a2[(*(tint_symbol_1)).i] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.msl
index 2d164b2..375695c 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,12 +22,8 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct S1 {
-  tint_array_wrapper a;
+  tint_array<InnerS, 8> a;
 };
 
 struct OuterS {
@@ -24,7 +33,7 @@
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
-  s1.s2.a.arr[(*(tint_symbol_1)).i] = v;
+  s1.s2.a[(*(tint_symbol_1)).i] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.msl
index 766be46..bccd603 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.msl
@@ -1,16 +1,25 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
 
-struct tint_array_wrapper {
-  uint arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<uint, 8> a1;
 };
 
 uint f(uint i) {
@@ -20,8 +29,8 @@
 kernel void tint_symbol(const constant Uniforms* tint_symbol_2 [[buffer(0)]]) {
   OuterS s1 = {};
   float3 v = 0.0f;
-  v[s1.a1.arr[(*(tint_symbol_2)).i]] = 1.0f;
-  uint const tint_symbol_1 = f(s1.a1.arr[(*(tint_symbol_2)).i]);
+  v[s1.a1[(*(tint_symbol_2)).i]] = 1.0f;
+  uint const tint_symbol_1 = f(s1.a1[(*(tint_symbol_2)).i]);
   v[tint_symbol_1] = 1.0f;
   return;
 }
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.msl
index 2f71f6e..573c567 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,19 +22,15 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_1 [[buffer(0)]]) {
   InnerS v = {};
   OuterS s1 = {};
   uint const p_save = (*(tint_symbol_1)).i;
-  s1.a1.arr[p_save] = v;
+  s1.a1[p_save] = v;
   return;
 }
 
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.msl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.msl
index 6ceb36f..9d025d3 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.msl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct Uniforms {
   /* 0x0000 */ uint i;
 };
@@ -9,17 +22,13 @@
   int v;
 };
 
-struct tint_array_wrapper {
-  InnerS arr[8];
-};
-
 struct OuterS {
-  tint_array_wrapper a1;
+  tint_array<InnerS, 8> a1;
 };
 
 void f(thread OuterS* const p, const constant Uniforms* const tint_symbol_1) {
   InnerS v = {};
-  (*(p)).a1.arr[(*(tint_symbol_1)).i] = v;
+  (*(p)).a1[(*(tint_symbol_1)).i] = v;
 }
 
 kernel void tint_symbol(const constant Uniforms* tint_symbol_2 [[buffer(0)]]) {
diff --git a/test/tint/statements/assign/phony/addr_of_non_constructable.wgsl.expected.msl b/test/tint/statements/assign/phony/addr_of_non_constructable.wgsl.expected.msl
index 2f29265..90a2b8d 100644
--- a/test/tint/statements/assign/phony/addr_of_non_constructable.wgsl.expected.msl
+++ b/test/tint/statements/assign/phony/addr_of_non_constructable.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
-  int arr[1];
+  tint_array<int, 1> arr;
 };
 
 kernel void tint_symbol() {
diff --git a/test/tint/statements/assign/phony/addr_of_runtime_array.wgsl.expected.msl b/test/tint/statements/assign/phony/addr_of_runtime_array.wgsl.expected.msl
index 2f29265..90a2b8d 100644
--- a/test/tint/statements/assign/phony/addr_of_runtime_array.wgsl.expected.msl
+++ b/test/tint/statements/assign/phony/addr_of_runtime_array.wgsl.expected.msl
@@ -1,8 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
-  int arr[1];
+  tint_array<int, 1> arr;
 };
 
 kernel void tint_symbol() {
diff --git a/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.msl b/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.msl
index 6a6d978..26fb806 100644
--- a/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.msl
+++ b/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  tint_array_wrapper a;
+  tint_array<int4, 4> a;
 };
 
 int foo(thread int* const tint_symbol_4) {
@@ -24,6 +33,6 @@
   int const tint_symbol_3 = foo(tint_symbol_6);
   int const tint_symbol_1_save = tint_symbol_3;
   int const tint_symbol_2 = bar(tint_symbol_6);
-  x.a.arr[tint_symbol_1_save][tint_symbol_2] = as_type<int>((as_type<uint>(x.a.arr[tint_symbol_1_save][tint_symbol_2]) + as_type<uint>(5)));
+  x.a[tint_symbol_1_save][tint_symbol_2] = as_type<int>((as_type<uint>(x.a[tint_symbol_1_save][tint_symbol_2]) + as_type<uint>(5)));
 }
 
diff --git a/test/tint/statements/compound_assign/for_loop.wgsl.expected.msl b/test/tint/statements/compound_assign/for_loop.wgsl.expected.msl
index 4fb8c50..36309e9 100644
--- a/test/tint/statements/compound_assign/for_loop.wgsl.expected.msl
+++ b/test/tint/statements/compound_assign/for_loop.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   int a;
   float4 b;
@@ -22,19 +35,15 @@
   return 1;
 }
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
 void foo(thread uint* const tint_symbol_8) {
-  tint_array_wrapper a = {.arr={}};
+  tint_array<float, 4> a = tint_array<float, 4>{};
   int const tint_symbol_2 = idx1(tint_symbol_8);
   int const tint_symbol_save = tint_symbol_2;
   {
-    a.arr[tint_symbol_save] = (a.arr[tint_symbol_save] * 2.0f);
+    a[tint_symbol_save] = (a[tint_symbol_save] * 2.0f);
     while (true) {
       int const tint_symbol_3 = idx2(tint_symbol_8);
-      if (!((a.arr[tint_symbol_3] < 10.0f))) {
+      if (!((a[tint_symbol_3] < 10.0f))) {
         break;
       }
       {
@@ -42,7 +51,7 @@
       {
         int const tint_symbol_4 = idx3(tint_symbol_8);
         int const tint_symbol_1_save = tint_symbol_4;
-        a.arr[tint_symbol_1_save] = (a.arr[tint_symbol_1_save] + 1.0f);
+        a[tint_symbol_1_save] = (a[tint_symbol_1_save] + 1.0f);
       }
     }
   }
diff --git a/test/tint/statements/decrement/array_element.wgsl.expected.msl b/test/tint/statements/decrement/array_element.wgsl.expected.msl
index 03752fb..56896d1 100644
--- a/test/tint/statements/decrement/array_element.wgsl.expected.msl
+++ b/test/tint/statements/decrement/array_element.wgsl.expected.msl
@@ -1,7 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-void tint_symbol(device uint (*const tint_symbol_2)[1]) {
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+void tint_symbol(device tint_array<uint, 1>* const tint_symbol_2) {
   (*(tint_symbol_2))[1] = ((*(tint_symbol_2))[1] - 1u);
 }
 
diff --git a/test/tint/statements/decrement/complex.wgsl.expected.msl b/test/tint/statements/decrement/complex.wgsl.expected.msl
index e7e4a6c..ece89e4 100644
--- a/test/tint/statements/decrement/complex.wgsl.expected.msl
+++ b/test/tint/statements/decrement/complex.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper a;
+  /* 0x0000 */ tint_array<int4, 4> a;
 };
 
 int idx1(thread uint* const tint_symbol_10) {
@@ -39,14 +48,14 @@
   return 2;
 }
 
-void tint_symbol_1(thread uint* const tint_symbol_16, device S (*const tint_symbol_17)[1]) {
+void tint_symbol_1(thread uint* const tint_symbol_16, device tint_array<S, 1>* const tint_symbol_17) {
   int const tint_symbol_6 = idx1(tint_symbol_16);
   int const tint_symbol_7 = idx2(tint_symbol_16);
   int const tint_symbol_2_save = tint_symbol_6;
   int const tint_symbol_2_save_1 = tint_symbol_7;
   int const tint_symbol_3 = idx3(tint_symbol_16);
   {
-    (*(tint_symbol_17))[tint_symbol_2_save].a.arr[tint_symbol_2_save_1][tint_symbol_3] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_2_save].a.arr[tint_symbol_2_save_1][tint_symbol_3]) - as_type<uint>(1)));
+    (*(tint_symbol_17))[tint_symbol_2_save].a[tint_symbol_2_save_1][tint_symbol_3] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_2_save].a[tint_symbol_2_save_1][tint_symbol_3]) - as_type<uint>(1)));
     while (true) {
       if (!((*(tint_symbol_16) < 10u))) {
         break;
@@ -59,7 +68,7 @@
         int const tint_symbol_4_save = tint_symbol_8;
         int const tint_symbol_4_save_1 = tint_symbol_9;
         int const tint_symbol_5 = idx6(tint_symbol_16);
-        (*(tint_symbol_17))[tint_symbol_4_save].a.arr[tint_symbol_4_save_1][tint_symbol_5] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_4_save].a.arr[tint_symbol_4_save_1][tint_symbol_5]) - as_type<uint>(1)));
+        (*(tint_symbol_17))[tint_symbol_4_save].a[tint_symbol_4_save_1][tint_symbol_5] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_4_save].a[tint_symbol_4_save_1][tint_symbol_5]) - as_type<uint>(1)));
       }
     }
   }
diff --git a/test/tint/statements/for/condition/array_ctor.wgsl.expected.msl b/test/tint/statements/for/condition/array_ctor.wgsl.expected.msl
index 5aefd59..ffacf97 100644
--- a/test/tint/statements/for/condition/array_ctor.wgsl.expected.msl
+++ b/test/tint/statements/for/condition/array_ctor.wgsl.expected.msl
@@ -1,15 +1,24 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[1];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
   int i = 0;
   while (true) {
-    tint_array_wrapper const tint_symbol = {.arr={1}};
-    if (!((i < tint_symbol.arr[0]))) {
+    tint_array<int, 1> const tint_symbol = tint_array<int, 1>{1};
+    if (!((i < 1))) {
       break;
     }
     {
diff --git a/test/tint/statements/for/continuing/array_ctor.wgsl.expected.msl b/test/tint/statements/for/continuing/array_ctor.wgsl.expected.msl
index ac6ffc2..e596e14 100644
--- a/test/tint/statements/for/continuing/array_ctor.wgsl.expected.msl
+++ b/test/tint/statements/for/continuing/array_ctor.wgsl.expected.msl
@@ -1,8 +1,17 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[1];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
@@ -14,8 +23,8 @@
     {
     }
     {
-      tint_array_wrapper const tint_symbol = {.arr={1}};
-      i = as_type<int>((as_type<uint>(i) + as_type<uint>(tint_symbol.arr[0])));
+      tint_array<int, 1> const tint_symbol = tint_array<int, 1>{1};
+      i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)));
     }
   }
 }
diff --git a/test/tint/statements/for/initializer/array_ctor.wgsl.expected.msl b/test/tint/statements/for/initializer/array_ctor.wgsl.expected.msl
index aa3d065..f729fc7 100644
--- a/test/tint/statements/for/initializer/array_ctor.wgsl.expected.msl
+++ b/test/tint/statements/for/initializer/array_ctor.wgsl.expected.msl
@@ -1,13 +1,22 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  int arr[1];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 void f() {
-  tint_array_wrapper const tint_symbol = {.arr={1}};
-  for(int i = tint_symbol.arr[0]; false; ) {
+  tint_array<int, 1> const tint_symbol = tint_array<int, 1>{1};
+  for(int i = 1; false; ) {
   }
 }
 
diff --git a/test/tint/statements/increment/array_element.wgsl.expected.msl b/test/tint/statements/increment/array_element.wgsl.expected.msl
index 0347508..4d41bf9 100644
--- a/test/tint/statements/increment/array_element.wgsl.expected.msl
+++ b/test/tint/statements/increment/array_element.wgsl.expected.msl
@@ -1,7 +1,20 @@
 #include <metal_stdlib>
 
 using namespace metal;
-void tint_symbol(device uint (*const tint_symbol_2)[1]) {
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+void tint_symbol(device tint_array<uint, 1>* const tint_symbol_2) {
   (*(tint_symbol_2))[1] = ((*(tint_symbol_2))[1] + 1u);
 }
 
diff --git a/test/tint/statements/increment/complex.wgsl.expected.msl b/test/tint/statements/increment/complex.wgsl.expected.msl
index fbc0f9c..3f31988 100644
--- a/test/tint/statements/increment/complex.wgsl.expected.msl
+++ b/test/tint/statements/increment/complex.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct tint_array_wrapper {
-  /* 0x0000 */ int4 arr[4];
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
 struct S {
-  /* 0x0000 */ tint_array_wrapper a;
+  /* 0x0000 */ tint_array<int4, 4> a;
 };
 
 int idx1(thread uint* const tint_symbol_10) {
@@ -39,14 +48,14 @@
   return 2;
 }
 
-void tint_symbol_1(thread uint* const tint_symbol_16, device S (*const tint_symbol_17)[1]) {
+void tint_symbol_1(thread uint* const tint_symbol_16, device tint_array<S, 1>* const tint_symbol_17) {
   int const tint_symbol_6 = idx1(tint_symbol_16);
   int const tint_symbol_7 = idx2(tint_symbol_16);
   int const tint_symbol_2_save = tint_symbol_6;
   int const tint_symbol_2_save_1 = tint_symbol_7;
   int const tint_symbol_3 = idx3(tint_symbol_16);
   {
-    (*(tint_symbol_17))[tint_symbol_2_save].a.arr[tint_symbol_2_save_1][tint_symbol_3] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_2_save].a.arr[tint_symbol_2_save_1][tint_symbol_3]) + as_type<uint>(1)));
+    (*(tint_symbol_17))[tint_symbol_2_save].a[tint_symbol_2_save_1][tint_symbol_3] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_2_save].a[tint_symbol_2_save_1][tint_symbol_3]) + as_type<uint>(1)));
     while (true) {
       if (!((*(tint_symbol_16) < 10u))) {
         break;
@@ -59,7 +68,7 @@
         int const tint_symbol_4_save = tint_symbol_8;
         int const tint_symbol_4_save_1 = tint_symbol_9;
         int const tint_symbol_5 = idx6(tint_symbol_16);
-        (*(tint_symbol_17))[tint_symbol_4_save].a.arr[tint_symbol_4_save_1][tint_symbol_5] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_4_save].a.arr[tint_symbol_4_save_1][tint_symbol_5]) + as_type<uint>(1)));
+        (*(tint_symbol_17))[tint_symbol_4_save].a[tint_symbol_4_save_1][tint_symbol_5] = as_type<int>((as_type<uint>((*(tint_symbol_17))[tint_symbol_4_save].a[tint_symbol_4_save_1][tint_symbol_5]) + as_type<uint>(1)));
       }
     }
   }
diff --git a/test/tint/struct/type_constructor.wgsl.expected.msl b/test/tint/struct/type_constructor.wgsl.expected.msl
index d0449b8..6e691c0 100644
--- a/test/tint/struct/type_constructor.wgsl.expected.msl
+++ b/test/tint/struct/type_constructor.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S1 {
   int a;
   int b;
@@ -19,16 +32,8 @@
   S2 i;
 };
 
-struct tint_array_wrapper {
-  int arr[2];
-};
-
 struct T {
-  tint_array_wrapper a;
-};
-
-struct tint_array_wrapper_1 {
-  T arr[2];
+  tint_array<int, 2> a;
 };
 
 kernel void tint_symbol() {
@@ -58,15 +63,15 @@
   S1 const tint_symbol_12 = {.a=2, .b=42, .c=as_type<int>((as_type<uint>(42) + as_type<uint>(1))), .d=nested_nonempty.i.f.d};
   S2 const tint_symbol_13 = {.e=1, .f=tint_symbol_12};
   S1 const subexpr_nested_nonempty_with_expr = tint_symbol_13.f;
-  tint_array_wrapper_1 const aosoa_empty = {.arr={}};
-  tint_array_wrapper const tint_symbol_14 = {.arr={1, 2}};
+  tint_array<T, 2> const aosoa_empty = tint_array<T, 2>{};
+  tint_array<int, 2> const tint_symbol_14 = tint_array<int, 2>{1, 2};
   T const tint_symbol_15 = {.a=tint_symbol_14};
-  tint_array_wrapper const tint_symbol_16 = {.arr={3, 4}};
+  tint_array<int, 2> const tint_symbol_16 = tint_array<int, 2>{3, 4};
   T const tint_symbol_17 = {.a=tint_symbol_16};
-  tint_array_wrapper_1 const aosoa_nonempty = {.arr={tint_symbol_15, tint_symbol_17}};
-  tint_array_wrapper const tint_symbol_18 = {.arr={1, as_type<int>((as_type<uint>(aosoa_nonempty.arr[0].a.arr[0]) + as_type<uint>(1)))}};
+  tint_array<T, 2> const aosoa_nonempty = tint_array<T, 2>{tint_symbol_15, tint_symbol_17};
+  tint_array<int, 2> const tint_symbol_18 = tint_array<int, 2>{1, as_type<int>((as_type<uint>(aosoa_nonempty[0].a[0]) + as_type<uint>(1)))};
   T const tint_symbol_19 = {.a=tint_symbol_18};
-  tint_array_wrapper_1 const aosoa_nonempty_with_expr = {.arr={tint_symbol_19, aosoa_nonempty.arr[1]}};
+  tint_array<T, 2> const aosoa_nonempty_with_expr = tint_array<T, 2>{tint_symbol_19, aosoa_nonempty[1]};
   return;
 }
 
diff --git a/test/tint/types/function_scope_declarations.wgsl.expected.msl b/test/tint/types/function_scope_declarations.wgsl.expected.msl
index 799d28a..a7cd381 100644
--- a/test/tint/types/function_scope_declarations.wgsl.expected.msl
+++ b/test/tint/types/function_scope_declarations.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct S {
-  float a;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[4];
+struct S {
+  float a;
 };
 
 kernel void tint_symbol() {
@@ -26,8 +35,8 @@
   float4 const v4f32_let = float4(0.0f);
   float2x3 m2x3_var = float2x3(float3(0.0f), float3(0.0f));
   float3x4 const m3x4_let = float3x4(float4(0.0f), float4(0.0f), float4(0.0f));
-  tint_array_wrapper arr_var = {.arr={}};
-  tint_array_wrapper const arr_let = {.arr={}};
+  tint_array<float, 4> arr_var = tint_array<float, 4>{};
+  tint_array<float, 4> const arr_let = tint_array<float, 4>{};
   S struct_var = {};
   S const struct_let = {};
   return;
diff --git a/test/tint/types/module_scope_let.wgsl.expected.msl b/test/tint/types/module_scope_let.wgsl.expected.msl
index 33ba095..a48f863 100644
--- a/test/tint/types/module_scope_let.wgsl.expected.msl
+++ b/test/tint/types/module_scope_let.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   float a;
 };
@@ -21,11 +34,7 @@
 
 constant float3x4 m3x4_let = float3x4(float4(0.0f), float4(0.0f), float4(0.0f));
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
-constant tint_array_wrapper arr_let = {.arr={}};
+constant tint_array<float, 4> arr_let = tint_array<float, 4>{};
 
 constant S struct_let = {};
 
diff --git a/test/tint/types/module_scope_var.wgsl.expected.msl b/test/tint/types/module_scope_var.wgsl.expected.msl
index b4cb6cd..50d0091 100644
--- a/test/tint/types/module_scope_var.wgsl.expected.msl
+++ b/test/tint/types/module_scope_var.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct S {
-  float a;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[4];
+struct S {
+  float a;
 };
 
 kernel void tint_symbol() {
@@ -18,7 +27,7 @@
   thread uint3 tint_symbol_8 = 0u;
   thread float4 tint_symbol_9 = 0.0f;
   thread float2x3 tint_symbol_10 = float2x3(0.0f);
-  thread tint_array_wrapper tint_symbol_11 = {};
+  thread tint_array<float, 4> tint_symbol_11 = {};
   thread S tint_symbol_12 = {};
   tint_symbol_3 = false;
   tint_symbol_4 = 0;
@@ -28,7 +37,7 @@
   tint_symbol_8 = uint3(0u);
   tint_symbol_9 = float4(0.0f);
   tint_symbol_10 = float2x3(float3(0.0f), float3(0.0f));
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+  tint_array<float, 4> const tint_symbol_1 = tint_array<float, 4>{};
   tint_symbol_11 = tint_symbol_1;
   S const tint_symbol_2 = {};
   tint_symbol_12 = tint_symbol_2;
diff --git a/test/tint/types/module_scope_var_initializers.wgsl.expected.msl b/test/tint/types/module_scope_var_initializers.wgsl.expected.msl
index 815f9fb..e56e653 100644
--- a/test/tint/types/module_scope_var_initializers.wgsl.expected.msl
+++ b/test/tint/types/module_scope_var_initializers.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct S {
-  float a;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[4];
+struct S {
+  float a;
 };
 
 kernel void tint_symbol() {
@@ -18,7 +27,7 @@
   thread uint3 tint_symbol_8 = uint3(0u);
   thread float4 tint_symbol_9 = float4(0.0f);
   thread float2x3 tint_symbol_10 = float2x3(float3(0.0f), float3(0.0f));
-  thread tint_array_wrapper tint_symbol_11 = {.arr={}};
+  thread tint_array<float, 4> tint_symbol_11 = tint_array<float, 4>{};
   thread S tint_symbol_12 = {};
   tint_symbol_3 = false;
   tint_symbol_4 = 0;
@@ -28,7 +37,7 @@
   tint_symbol_8 = uint3(0u);
   tint_symbol_9 = float4(0.0f);
   tint_symbol_10 = float2x3(float3(0.0f), float3(0.0f));
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+  tint_array<float, 4> const tint_symbol_1 = tint_array<float, 4>{};
   tint_symbol_11 = tint_symbol_1;
   S const tint_symbol_2 = {};
   tint_symbol_12 = tint_symbol_2;
diff --git a/test/tint/types/parameters.wgsl.expected.msl b/test/tint/types/parameters.wgsl.expected.msl
index 3c1db25..54ad948 100644
--- a/test/tint/types/parameters.wgsl.expected.msl
+++ b/test/tint/types/parameters.wgsl.expected.msl
@@ -1,15 +1,24 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   float a;
 };
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
-void foo(bool param_bool, int param_i32, uint param_u32, float param_f32, int2 param_v2i32, uint3 param_v3u32, float4 param_v4f32, float2x3 param_m2x3, tint_array_wrapper param_arr, S param_struct, thread float* const param_ptr_f32, thread float4* const param_ptr_vec, thread tint_array_wrapper* const param_ptr_arr) {
+void foo(bool param_bool, int param_i32, uint param_u32, float param_f32, int2 param_v2i32, uint3 param_v3u32, float4 param_v4f32, float2x3 param_m2x3, tint_array<float, 4> param_arr, S param_struct, thread float* const param_ptr_f32, thread float4* const param_ptr_vec, thread tint_array<float, 4>* const param_ptr_arr) {
 }
 
 kernel void tint_symbol() {
diff --git a/test/tint/types/return_types.wgsl.expected.msl b/test/tint/types/return_types.wgsl.expected.msl
index 769204e..a0cf7b6 100644
--- a/test/tint/types/return_types.wgsl.expected.msl
+++ b/test/tint/types/return_types.wgsl.expected.msl
@@ -1,6 +1,19 @@
 #include <metal_stdlib>
 
 using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
 struct S {
   float a;
 };
@@ -37,12 +50,8 @@
   return float2x3(float3(0.0f), float3(0.0f));
 }
 
-struct tint_array_wrapper {
-  float arr[4];
-};
-
-tint_array_wrapper ret_arr() {
-  tint_array_wrapper const tint_symbol_1 = {.arr={}};
+tint_array<float, 4> ret_arr() {
+  tint_array<float, 4> const tint_symbol_1 = tint_array<float, 4>{};
   return tint_symbol_1;
 }
 
diff --git a/test/tint/types/struct_members.wgsl.expected.msl b/test/tint/types/struct_members.wgsl.expected.msl
index a43d5e0..03c6b97 100644
--- a/test/tint/types/struct_members.wgsl.expected.msl
+++ b/test/tint/types/struct_members.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct S_inner {
-  float a;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[4];
+struct S_inner {
+  float a;
 };
 
 struct S {
@@ -18,7 +27,7 @@
   uint3 member_v3u32;
   float4 member_v4f32;
   float2x3 member_m2x3;
-  tint_array_wrapper member_arr;
+  tint_array<float, 4> member_arr;
   S_inner member_struct;
 };
 
diff --git a/test/tint/var/inferred/function.wgsl.expected.msl b/test/tint/var/inferred/function.wgsl.expected.msl
index 8eebc86..8809684 100644
--- a/test/tint/var/inferred/function.wgsl.expected.msl
+++ b/test/tint/var/inferred/function.wgsl.expected.msl
@@ -1,12 +1,21 @@
 #include <metal_stdlib>
 
 using namespace metal;
-struct MyStruct {
-  float f1;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
 };
 
-struct tint_array_wrapper {
-  float arr[10];
+struct MyStruct {
+  float f1;
 };
 
 int ret_i32() {
@@ -26,8 +35,8 @@
   return tint_symbol_2;
 }
 
-tint_array_wrapper ret_MyArray() {
-  tint_array_wrapper const tint_symbol_3 = {.arr={}};
+tint_array<float, 10> ret_MyArray() {
+  tint_array<float, 10> const tint_symbol_3 = tint_array<float, 10>{};
   return tint_symbol_3;
 }
 
@@ -40,13 +49,13 @@
   float3 v6 = float3(1.0f);
   float3x3 v7 = float3x3(v6, v6, v6);
   MyStruct v8 = {.f1=1.0f};
-  tint_array_wrapper v9 = {.arr={}};
+  tint_array<float, 10> v9 = tint_array<float, 10>{};
   int v10 = ret_i32();
   uint v11 = ret_u32();
   float v12 = ret_f32();
   MyStruct v13 = ret_MyStruct();
   MyStruct v14 = ret_MyStruct();
-  tint_array_wrapper v15 = ret_MyArray();
+  tint_array<float, 10> v15 = ret_MyArray();
 }
 
 struct tint_symbol_1 {
diff --git a/test/tint/var/initialization/function/array.wgsl b/test/tint/var/initialization/function/array.wgsl
deleted file mode 100644
index 7b33431..0000000
--- a/test/tint/var/initialization/function/array.wgsl
+++ /dev/null
@@ -1,5 +0,0 @@
-@compute @workgroup_size(1)
-fn main() {
-    var v : array<i32, 3>;
-    _ = v;
-}
diff --git a/test/tint/var/initialization/function/array.wgsl.expected.glsl b/test/tint/var/initialization/function/array.wgsl.expected.glsl
deleted file mode 100644
index 645b82c..0000000
--- a/test/tint/var/initialization/function/array.wgsl.expected.glsl
+++ /dev/null
@@ -1,11 +0,0 @@
-#version 310 es
-
-void tint_symbol() {
-  int v[3] = int[3](0, 0, 0);
-}
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void main() {
-  tint_symbol();
-  return;
-}
diff --git a/test/tint/var/initialization/function/array.wgsl.expected.hlsl b/test/tint/var/initialization/function/array.wgsl.expected.hlsl
deleted file mode 100644
index 7f979a0..0000000
--- a/test/tint/var/initialization/function/array.wgsl.expected.hlsl
+++ /dev/null
@@ -1,5 +0,0 @@
-[numthreads(1, 1, 1)]
-void main() {
-  int v[3] = (int[3])0;
-  return;
-}
diff --git a/test/tint/var/initialization/function/array.wgsl.expected.msl b/test/tint/var/initialization/function/array.wgsl.expected.msl
deleted file mode 100644
index f441184..0000000
--- a/test/tint/var/initialization/function/array.wgsl.expected.msl
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <metal_stdlib>
-
-using namespace metal;
-struct tint_array_wrapper {
-  int arr[3];
-};
-
-kernel void tint_symbol() {
-  tint_array_wrapper v = {};
-  return;
-}
-
diff --git a/test/tint/var/initialization/function/array.wgsl.expected.wgsl b/test/tint/var/initialization/function/array.wgsl.expected.wgsl
deleted file mode 100644
index fc5ed43..0000000
--- a/test/tint/var/initialization/function/array.wgsl.expected.wgsl
+++ /dev/null
@@ -1,5 +0,0 @@
-@compute @workgroup_size(1)
-fn main() {
-  var v : array<i32, 3>;
-  _ = v;
-}
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl b/test/tint/var/initialization/function/array/array_i32.wgsl
new file mode 100644
index 0000000..80db613
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl
@@ -0,0 +1,5 @@
+@compute @workgroup_size(1)
+fn main() {
+    var zero : array<array<i32, 3>, 2>;
+    var init : array<array<i32, 3>, 2> = array<array<i32, 3>, 2>(array<i32, 3>(1, 2, 3), array<i32, 3>(4, 5, 6));
+}
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl.expected.glsl b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.glsl
new file mode 100644
index 0000000..132ba50
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.glsl
@@ -0,0 +1,14 @@
+#version 310 es
+
+void tint_symbol() {
+  int zero[2][3] = int[2][3](int[3](0, 0, 0), int[3](0, 0, 0));
+  int tint_symbol_1[3] = int[3](1, 2, 3);
+  int tint_symbol_2[3] = int[3](4, 5, 6);
+  int init[2][3] = int[2][3](tint_symbol_1, tint_symbol_2);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  tint_symbol();
+  return;
+}
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl.expected.hlsl b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.hlsl
new file mode 100644
index 0000000..88d2dd3
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.hlsl
@@ -0,0 +1,8 @@
+[numthreads(1, 1, 1)]
+void main() {
+  int zero[2][3] = (int[2][3])0;
+  const int tint_symbol[3] = {1, 2, 3};
+  const int tint_symbol_1[3] = {4, 5, 6};
+  int init[2][3] = {tint_symbol, tint_symbol_1};
+  return;
+}
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl.expected.msl b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.msl
new file mode 100644
index 0000000..7ad097e
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.msl
@@ -0,0 +1,24 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+kernel void tint_symbol() {
+  tint_array<tint_array<int, 3>, 2> zero = {};
+  tint_array<int, 3> const tint_symbol_1 = tint_array<int, 3>{1, 2, 3};
+  tint_array<int, 3> const tint_symbol_2 = tint_array<int, 3>{4, 5, 6};
+  tint_array<tint_array<int, 3>, 2> init = tint_array<tint_array<int, 3>, 2>{tint_symbol_1, tint_symbol_2};
+  return;
+}
+
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl.expected.spvasm b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.spvasm
new file mode 100644
index 0000000..12e87cc
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.spvasm
@@ -0,0 +1,40 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 24
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %main "main"
+               OpExecutionMode %main LocalSize 1 1 1
+               OpName %main "main"
+               OpName %zero "zero"
+               OpName %init "init"
+               OpDecorate %_arr_int_uint_3 ArrayStride 4
+               OpDecorate %_arr__arr_int_uint_3_uint_2 ArrayStride 12
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+     %uint_3 = OpConstant %uint 3
+%_arr_int_uint_3 = OpTypeArray %int %uint_3
+     %uint_2 = OpConstant %uint 2
+%_arr__arr_int_uint_3_uint_2 = OpTypeArray %_arr_int_uint_3 %uint_2
+%_ptr_Function__arr__arr_int_uint_3_uint_2 = OpTypePointer Function %_arr__arr_int_uint_3_uint_2
+         %13 = OpConstantNull %_arr__arr_int_uint_3_uint_2
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %17 = OpConstantComposite %_arr_int_uint_3 %int_1 %int_2 %int_3
+      %int_4 = OpConstant %int 4
+      %int_5 = OpConstant %int 5
+      %int_6 = OpConstant %int 6
+         %21 = OpConstantComposite %_arr_int_uint_3 %int_4 %int_5 %int_6
+         %22 = OpConstantComposite %_arr__arr_int_uint_3_uint_2 %17 %21
+       %main = OpFunction %void None %1
+          %4 = OpLabel
+       %zero = OpVariable %_ptr_Function__arr__arr_int_uint_3_uint_2 Function %13
+       %init = OpVariable %_ptr_Function__arr__arr_int_uint_3_uint_2 Function %13
+               OpStore %init %22
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/var/initialization/function/array/array_i32.wgsl.expected.wgsl b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..9bf3787
--- /dev/null
+++ b/test/tint/var/initialization/function/array/array_i32.wgsl.expected.wgsl
@@ -0,0 +1,5 @@
+@compute @workgroup_size(1)
+fn main() {
+  var zero : array<array<i32, 3>, 2>;
+  var init : array<array<i32, 3>, 2> = array<array<i32, 3>, 2>(array<i32, 3>(1, 2, 3), array<i32, 3>(4, 5, 6));
+}
diff --git a/test/tint/var/initialization/function/array/i32.wgsl b/test/tint/var/initialization/function/array/i32.wgsl
new file mode 100644
index 0000000..5e83d39
--- /dev/null
+++ b/test/tint/var/initialization/function/array/i32.wgsl
@@ -0,0 +1,5 @@
+@compute @workgroup_size(1)
+fn main() {
+    var zero : array<i32, 3>;
+    var init : array<i32, 3> = array<i32, 3>(1, 2, 3);
+}
diff --git a/test/tint/var/initialization/private/array.wgsl.expected.glsl b/test/tint/var/initialization/function/array/i32.wgsl.expected.glsl
similarity index 69%
rename from test/tint/var/initialization/private/array.wgsl.expected.glsl
rename to test/tint/var/initialization/function/array/i32.wgsl.expected.glsl
index 7bbaf79..8cc2174 100644
--- a/test/tint/var/initialization/private/array.wgsl.expected.glsl
+++ b/test/tint/var/initialization/function/array/i32.wgsl.expected.glsl
@@ -1,7 +1,8 @@
 #version 310 es
 
-int v[3] = int[3](0, 0, 0);
 void tint_symbol() {
+  int zero[3] = int[3](0, 0, 0);
+  int init[3] = int[3](1, 2, 3);
 }
 
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
diff --git a/test/tint/var/initialization/function/array/i32.wgsl.expected.hlsl b/test/tint/var/initialization/function/array/i32.wgsl.expected.hlsl
new file mode 100644
index 0000000..93ed2c5
--- /dev/null
+++ b/test/tint/var/initialization/function/array/i32.wgsl.expected.hlsl
@@ -0,0 +1,6 @@
+[numthreads(1, 1, 1)]
+void main() {
+  int zero[3] = (int[3])0;
+  int init[3] = {1, 2, 3};
+  return;
+}
diff --git a/test/tint/var/initialization/function/array/i32.wgsl.expected.msl b/test/tint/var/initialization/function/array/i32.wgsl.expected.msl
new file mode 100644
index 0000000..e171bf3
--- /dev/null
+++ b/test/tint/var/initialization/function/array/i32.wgsl.expected.msl
@@ -0,0 +1,22 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+kernel void tint_symbol() {
+  tint_array<int, 3> zero = {};
+  tint_array<int, 3> init = tint_array<int, 3>{1, 2, 3};
+  return;
+}
+
diff --git a/test/tint/var/initialization/function/array.wgsl.expected.spvasm b/test/tint/var/initialization/function/array/i32.wgsl.expected.spvasm
similarity index 65%
rename from test/tint/var/initialization/function/array.wgsl.expected.spvasm
rename to test/tint/var/initialization/function/array/i32.wgsl.expected.spvasm
index 2112361..e61c1ab 100644
--- a/test/tint/var/initialization/function/array.wgsl.expected.spvasm
+++ b/test/tint/var/initialization/function/array/i32.wgsl.expected.spvasm
@@ -1,14 +1,15 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 12
+; Bound: 17
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
                OpEntryPoint GLCompute %main "main"
                OpExecutionMode %main LocalSize 1 1 1
                OpName %main "main"
-               OpName %v "v"
+               OpName %zero "zero"
+               OpName %init "init"
                OpDecorate %_arr_int_uint_3 ArrayStride 4
        %void = OpTypeVoid
           %1 = OpTypeFunction %void
@@ -18,8 +19,14 @@
 %_arr_int_uint_3 = OpTypeArray %int %uint_3
 %_ptr_Function__arr_int_uint_3 = OpTypePointer Function %_arr_int_uint_3
          %11 = OpConstantNull %_arr_int_uint_3
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %15 = OpConstantComposite %_arr_int_uint_3 %int_1 %int_2 %int_3
        %main = OpFunction %void None %1
           %4 = OpLabel
-          %v = OpVariable %_ptr_Function__arr_int_uint_3 Function %11
+       %zero = OpVariable %_ptr_Function__arr_int_uint_3 Function %11
+       %init = OpVariable %_ptr_Function__arr_int_uint_3 Function %11
+               OpStore %init %15
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/var/initialization/function/array/i32.wgsl.expected.wgsl b/test/tint/var/initialization/function/array/i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..70f7f20
--- /dev/null
+++ b/test/tint/var/initialization/function/array/i32.wgsl.expected.wgsl
@@ -0,0 +1,5 @@
+@compute @workgroup_size(1)
+fn main() {
+  var zero : array<i32, 3>;
+  var init : array<i32, 3> = array<i32, 3>(1, 2, 3);
+}
diff --git a/test/tint/var/initialization/private/array.wgsl b/test/tint/var/initialization/private/array.wgsl
deleted file mode 100644
index 266e4f2..0000000
--- a/test/tint/var/initialization/private/array.wgsl
+++ /dev/null
@@ -1,6 +0,0 @@
-var<private> v : array<i32, 3>;
-
-@compute @workgroup_size(1)
-fn main() {
-    _ = v;
-}
diff --git a/test/tint/var/initialization/private/array.wgsl.expected.hlsl b/test/tint/var/initialization/private/array.wgsl.expected.hlsl
deleted file mode 100644
index 5cedea9..0000000
--- a/test/tint/var/initialization/private/array.wgsl.expected.hlsl
+++ /dev/null
@@ -1,6 +0,0 @@
-static int v[3] = (int[3])0;
-
-[numthreads(1, 1, 1)]
-void main() {
-  return;
-}
diff --git a/test/tint/var/initialization/private/array.wgsl.expected.msl b/test/tint/var/initialization/private/array.wgsl.expected.msl
deleted file mode 100644
index e80edf9..0000000
--- a/test/tint/var/initialization/private/array.wgsl.expected.msl
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <metal_stdlib>
-
-using namespace metal;
-struct tint_array_wrapper {
-  int arr[3];
-};
-
-kernel void tint_symbol() {
-  return;
-}
-
diff --git a/test/tint/var/initialization/private/array.wgsl.expected.spvasm b/test/tint/var/initialization/private/array.wgsl.expected.spvasm
deleted file mode 100644
index 90c0ea5..0000000
--- a/test/tint/var/initialization/private/array.wgsl.expected.spvasm
+++ /dev/null
@@ -1,25 +0,0 @@
-; SPIR-V
-; Version: 1.3
-; Generator: Google Tint Compiler; 0
-; Bound: 12
-; Schema: 0
-               OpCapability Shader
-               OpMemoryModel Logical GLSL450
-               OpEntryPoint GLCompute %main "main"
-               OpExecutionMode %main LocalSize 1 1 1
-               OpName %v "v"
-               OpName %main "main"
-               OpDecorate %_arr_int_uint_3 ArrayStride 4
-        %int = OpTypeInt 32 1
-       %uint = OpTypeInt 32 0
-     %uint_3 = OpConstant %uint 3
-%_arr_int_uint_3 = OpTypeArray %int %uint_3
-%_ptr_Private__arr_int_uint_3 = OpTypePointer Private %_arr_int_uint_3
-          %7 = OpConstantNull %_arr_int_uint_3
-          %v = OpVariable %_ptr_Private__arr_int_uint_3 Private %7
-       %void = OpTypeVoid
-          %8 = OpTypeFunction %void
-       %main = OpFunction %void None %8
-         %11 = OpLabel
-               OpReturn
-               OpFunctionEnd
diff --git a/test/tint/var/initialization/private/array.wgsl.expected.wgsl b/test/tint/var/initialization/private/array.wgsl.expected.wgsl
deleted file mode 100644
index 478777e..0000000
--- a/test/tint/var/initialization/private/array.wgsl.expected.wgsl
+++ /dev/null
@@ -1,6 +0,0 @@
-var<private> v : array<i32, 3>;
-
-@compute @workgroup_size(1)
-fn main() {
-  _ = v;
-}
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl b/test/tint/var/initialization/private/array/array_i32.wgsl
new file mode 100644
index 0000000..91547ae
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl
@@ -0,0 +1,8 @@
+var<private> zero : array<array<i32, 3>, 2>;
+var<private> init : array<array<i32, 3>, 2> = array<array<i32, 3>, 2>(array<i32, 3>(1, 2, 3), array<i32, 3>(4, 5, 6));
+
+@compute @workgroup_size(1)
+fn main() {
+    var v0 = zero;
+    var v1 = init;
+}
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl.expected.glsl b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.glsl
new file mode 100644
index 0000000..9ca3db0
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.glsl
@@ -0,0 +1,14 @@
+#version 310 es
+
+int zero[2][3] = int[2][3](int[3](0, 0, 0), int[3](0, 0, 0));
+int init[2][3] = int[2][3](int[3](1, 2, 3), int[3](4, 5, 6));
+void tint_symbol() {
+  int v0[2][3] = zero;
+  int v1[2][3] = init;
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  tint_symbol();
+  return;
+}
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl.expected.hlsl b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.hlsl
new file mode 100644
index 0000000..aa728ab
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.hlsl
@@ -0,0 +1,9 @@
+static int zero[2][3] = (int[2][3])0;
+static int init[2][3] = {{1, 2, 3}, {4, 5, 6}};
+
+[numthreads(1, 1, 1)]
+void main() {
+  int v0[2][3] = zero;
+  int v1[2][3] = init;
+  return;
+}
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl.expected.msl b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.msl
new file mode 100644
index 0000000..33ba833
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.msl
@@ -0,0 +1,24 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+kernel void tint_symbol() {
+  thread tint_array<tint_array<int, 3>, 2> tint_symbol_1 = {};
+  thread tint_array<tint_array<int, 3>, 2> tint_symbol_2 = tint_array<tint_array<int, 3>, 2>{tint_array<int, 3>{1, 2, 3}, tint_array<int, 3>{4, 5, 6}};
+  tint_array<tint_array<int, 3>, 2> v0 = tint_symbol_1;
+  tint_array<tint_array<int, 3>, 2> v1 = tint_symbol_2;
+  return;
+}
+
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl.expected.spvasm b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.spvasm
new file mode 100644
index 0000000..81e5d8b
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.spvasm
@@ -0,0 +1,48 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 29
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %main "main"
+               OpExecutionMode %main LocalSize 1 1 1
+               OpName %zero "zero"
+               OpName %init "init"
+               OpName %main "main"
+               OpName %v0 "v0"
+               OpName %v1 "v1"
+               OpDecorate %_arr_int_uint_3 ArrayStride 4
+               OpDecorate %_arr__arr_int_uint_3_uint_2 ArrayStride 12
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+     %uint_3 = OpConstant %uint 3
+%_arr_int_uint_3 = OpTypeArray %int %uint_3
+     %uint_2 = OpConstant %uint 2
+%_arr__arr_int_uint_3_uint_2 = OpTypeArray %_arr_int_uint_3 %uint_2
+%_ptr_Private__arr__arr_int_uint_3_uint_2 = OpTypePointer Private %_arr__arr_int_uint_3_uint_2
+          %9 = OpConstantNull %_arr__arr_int_uint_3_uint_2
+       %zero = OpVariable %_ptr_Private__arr__arr_int_uint_3_uint_2 Private %9
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %13 = OpConstantComposite %_arr_int_uint_3 %int_1 %int_2 %int_3
+      %int_4 = OpConstant %int 4
+      %int_5 = OpConstant %int 5
+      %int_6 = OpConstant %int 6
+         %17 = OpConstantComposite %_arr_int_uint_3 %int_4 %int_5 %int_6
+         %18 = OpConstantComposite %_arr__arr_int_uint_3_uint_2 %13 %17
+       %init = OpVariable %_ptr_Private__arr__arr_int_uint_3_uint_2 Private %18
+       %void = OpTypeVoid
+         %20 = OpTypeFunction %void
+%_ptr_Function__arr__arr_int_uint_3_uint_2 = OpTypePointer Function %_arr__arr_int_uint_3_uint_2
+       %main = OpFunction %void None %20
+         %23 = OpLabel
+         %v0 = OpVariable %_ptr_Function__arr__arr_int_uint_3_uint_2 Function %9
+         %v1 = OpVariable %_ptr_Function__arr__arr_int_uint_3_uint_2 Function %9
+         %24 = OpLoad %_arr__arr_int_uint_3_uint_2 %zero
+               OpStore %v0 %24
+         %27 = OpLoad %_arr__arr_int_uint_3_uint_2 %init
+               OpStore %v1 %27
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/var/initialization/private/array/array_i32.wgsl.expected.wgsl b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..4480574
--- /dev/null
+++ b/test/tint/var/initialization/private/array/array_i32.wgsl.expected.wgsl
@@ -0,0 +1,9 @@
+var<private> zero : array<array<i32, 3>, 2>;
+
+var<private> init : array<array<i32, 3>, 2> = array<array<i32, 3>, 2>(array<i32, 3>(1, 2, 3), array<i32, 3>(4, 5, 6));
+
+@compute @workgroup_size(1)
+fn main() {
+  var v0 = zero;
+  var v1 = init;
+}
diff --git a/test/tint/var/initialization/private/array/i32.wgsl b/test/tint/var/initialization/private/array/i32.wgsl
new file mode 100644
index 0000000..c17920a
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl
@@ -0,0 +1,8 @@
+var<private> zero : array<i32, 3>;
+var<private> init : array<i32, 3> = array<i32, 3>(1, 2, 3);
+
+@compute @workgroup_size(1)
+fn main() {
+    var v0 = zero;
+    var v1 = init;
+}
diff --git a/test/tint/var/initialization/private/array/i32.wgsl.expected.glsl b/test/tint/var/initialization/private/array/i32.wgsl.expected.glsl
new file mode 100644
index 0000000..956d196
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl.expected.glsl
@@ -0,0 +1,14 @@
+#version 310 es
+
+int zero[3] = int[3](0, 0, 0);
+int init[3] = int[3](1, 2, 3);
+void tint_symbol() {
+  int v0[3] = zero;
+  int v1[3] = init;
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  tint_symbol();
+  return;
+}
diff --git a/test/tint/var/initialization/private/array/i32.wgsl.expected.hlsl b/test/tint/var/initialization/private/array/i32.wgsl.expected.hlsl
new file mode 100644
index 0000000..e4cc4bc
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl.expected.hlsl
@@ -0,0 +1,9 @@
+static int zero[3] = (int[3])0;
+static int init[3] = {1, 2, 3};
+
+[numthreads(1, 1, 1)]
+void main() {
+  int v0[3] = zero;
+  int v1[3] = init;
+  return;
+}
diff --git a/test/tint/var/initialization/private/array/i32.wgsl.expected.msl b/test/tint/var/initialization/private/array/i32.wgsl.expected.msl
new file mode 100644
index 0000000..60dac04
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl.expected.msl
@@ -0,0 +1,24 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+kernel void tint_symbol() {
+  thread tint_array<int, 3> tint_symbol_1 = {};
+  thread tint_array<int, 3> tint_symbol_2 = tint_array<int, 3>{1, 2, 3};
+  tint_array<int, 3> v0 = tint_symbol_1;
+  tint_array<int, 3> v1 = tint_symbol_2;
+  return;
+}
+
diff --git a/test/tint/var/initialization/private/array/i32.wgsl.expected.spvasm b/test/tint/var/initialization/private/array/i32.wgsl.expected.spvasm
new file mode 100644
index 0000000..0ca3cd6
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl.expected.spvasm
@@ -0,0 +1,40 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 22
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %main "main"
+               OpExecutionMode %main LocalSize 1 1 1
+               OpName %zero "zero"
+               OpName %init "init"
+               OpName %main "main"
+               OpName %v0 "v0"
+               OpName %v1 "v1"
+               OpDecorate %_arr_int_uint_3 ArrayStride 4
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+     %uint_3 = OpConstant %uint 3
+%_arr_int_uint_3 = OpTypeArray %int %uint_3
+%_ptr_Private__arr_int_uint_3 = OpTypePointer Private %_arr_int_uint_3
+          %7 = OpConstantNull %_arr_int_uint_3
+       %zero = OpVariable %_ptr_Private__arr_int_uint_3 Private %7
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %11 = OpConstantComposite %_arr_int_uint_3 %int_1 %int_2 %int_3
+       %init = OpVariable %_ptr_Private__arr_int_uint_3 Private %11
+       %void = OpTypeVoid
+         %13 = OpTypeFunction %void
+%_ptr_Function__arr_int_uint_3 = OpTypePointer Function %_arr_int_uint_3
+       %main = OpFunction %void None %13
+         %16 = OpLabel
+         %v0 = OpVariable %_ptr_Function__arr_int_uint_3 Function %7
+         %v1 = OpVariable %_ptr_Function__arr_int_uint_3 Function %7
+         %17 = OpLoad %_arr_int_uint_3 %zero
+               OpStore %v0 %17
+         %20 = OpLoad %_arr_int_uint_3 %init
+               OpStore %v1 %20
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/var/initialization/private/array/i32.wgsl.expected.wgsl b/test/tint/var/initialization/private/array/i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..59f9448
--- /dev/null
+++ b/test/tint/var/initialization/private/array/i32.wgsl.expected.wgsl
@@ -0,0 +1,9 @@
+var<private> zero : array<i32, 3>;
+
+var<private> init : array<i32, 3> = array<i32, 3>(1, 2, 3);
+
+@compute @workgroup_size(1)
+fn main() {
+  var v0 = zero;
+  var v1 = init;
+}
diff --git a/test/tint/var/initialization/workgroup/array.wgsl b/test/tint/var/initialization/workgroup/array.wgsl
deleted file mode 100644
index f3b6972..0000000
--- a/test/tint/var/initialization/workgroup/array.wgsl
+++ /dev/null
@@ -1,6 +0,0 @@
-var<workgroup> v : array<i32, 3>;
-
-@compute @workgroup_size(1)
-fn main() {
-    _ = v;
-}
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.msl b/test/tint/var/initialization/workgroup/array.wgsl.expected.msl
deleted file mode 100644
index 9157d88..0000000
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.msl
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <metal_stdlib>
-
-using namespace metal;
-struct tint_array_wrapper {
-  int arr[3];
-};
-
-void tint_symbol_inner(uint local_invocation_index, threadgroup tint_array_wrapper* const tint_symbol_1) {
-  for(uint idx = local_invocation_index; (idx < 3u); idx = (idx + 1u)) {
-    uint const i = idx;
-    (*(tint_symbol_1)).arr[i] = 0;
-  }
-  threadgroup_barrier(mem_flags::mem_threadgroup);
-}
-
-kernel void tint_symbol(uint local_invocation_index [[thread_index_in_threadgroup]]) {
-  threadgroup tint_array_wrapper tint_symbol_2;
-  tint_symbol_inner(local_invocation_index, &(tint_symbol_2));
-  return;
-}
-
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.wgsl b/test/tint/var/initialization/workgroup/array.wgsl.expected.wgsl
deleted file mode 100644
index d1e084b..0000000
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.wgsl
+++ /dev/null
@@ -1,6 +0,0 @@
-var<workgroup> v : array<i32, 3>;
-
-@compute @workgroup_size(1)
-fn main() {
-  _ = v;
-}
diff --git a/test/tint/var/initialization/workgroup/array/array_i32.wgsl b/test/tint/var/initialization/workgroup/array/array_i32.wgsl
new file mode 100644
index 0000000..d7ba62c
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl
@@ -0,0 +1,6 @@
+var<workgroup> zero : array<array<i32, 3>, 2>;
+
+@compute @workgroup_size(1)
+fn main() {
+    var v = zero;
+}
diff --git a/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.glsl b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.glsl
new file mode 100644
index 0000000..a3ba5e2
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.glsl
@@ -0,0 +1,20 @@
+#version 310 es
+
+shared int zero[2][3];
+void tint_symbol(uint local_invocation_index) {
+  {
+    for(uint idx = local_invocation_index; (idx < 6u); idx = (idx + 1u)) {
+      uint i = (idx / 3u);
+      uint i_1 = (idx % 3u);
+      zero[i][i_1] = 0;
+    }
+  }
+  barrier();
+  int v[2][3] = zero;
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  tint_symbol(gl_LocalInvocationIndex);
+  return;
+}
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.hlsl
similarity index 60%
copy from test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl
copy to test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.hlsl
index 21c4cab..0bcec72 100644
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.hlsl
@@ -1,4 +1,4 @@
-groupshared int v[3];
+groupshared int zero[2][3];
 
 struct tint_symbol_1 {
   uint local_invocation_index : SV_GroupIndex;
@@ -6,12 +6,14 @@
 
 void main_inner(uint local_invocation_index) {
   {
-    [loop] for(uint idx = local_invocation_index; (idx < 3u); idx = (idx + 1u)) {
-      const uint i = idx;
-      v[i] = 0;
+    [loop] for(uint idx = local_invocation_index; (idx < 6u); idx = (idx + 1u)) {
+      const uint i = (idx / 3u);
+      const uint i_1 = (idx % 3u);
+      zero[i][i_1] = 0;
     }
   }
   GroupMemoryBarrierWithGroupSync();
+  int v[2][3] = zero;
 }
 
 [numthreads(1, 1, 1)]
diff --git a/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.msl b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.msl
new file mode 100644
index 0000000..81c7619
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.msl
@@ -0,0 +1,32 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+void tint_symbol_inner(uint local_invocation_index, threadgroup tint_array<tint_array<int, 3>, 2>* const tint_symbol_1) {
+  for(uint idx = local_invocation_index; (idx < 6u); idx = (idx + 1u)) {
+    uint const i = (idx / 3u);
+    uint const i_1 = (idx % 3u);
+    (*(tint_symbol_1))[i][i_1] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  tint_array<tint_array<int, 3>, 2> v = *(tint_symbol_1);
+}
+
+kernel void tint_symbol(uint local_invocation_index [[thread_index_in_threadgroup]]) {
+  threadgroup tint_array<tint_array<int, 3>, 2> tint_symbol_2;
+  tint_symbol_inner(local_invocation_index, &(tint_symbol_2));
+  return;
+}
+
diff --git a/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.spvasm b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.spvasm
new file mode 100644
index 0000000..ff32eed
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.spvasm
@@ -0,0 +1,85 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 51
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %main "main" %local_invocation_index_1
+               OpExecutionMode %main LocalSize 1 1 1
+               OpName %local_invocation_index_1 "local_invocation_index_1"
+               OpName %zero "zero"
+               OpName %main_inner "main_inner"
+               OpName %local_invocation_index "local_invocation_index"
+               OpName %idx "idx"
+               OpName %v "v"
+               OpName %main "main"
+               OpDecorate %local_invocation_index_1 BuiltIn LocalInvocationIndex
+               OpDecorate %_arr_int_uint_3 ArrayStride 4
+               OpDecorate %_arr__arr_int_uint_3_uint_2 ArrayStride 12
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+%local_invocation_index_1 = OpVariable %_ptr_Input_uint Input
+        %int = OpTypeInt 32 1
+     %uint_3 = OpConstant %uint 3
+%_arr_int_uint_3 = OpTypeArray %int %uint_3
+     %uint_2 = OpConstant %uint 2
+%_arr__arr_int_uint_3_uint_2 = OpTypeArray %_arr_int_uint_3 %uint_2
+%_ptr_Workgroup__arr__arr_int_uint_3_uint_2 = OpTypePointer Workgroup %_arr__arr_int_uint_3_uint_2
+       %zero = OpVariable %_ptr_Workgroup__arr__arr_int_uint_3_uint_2 Workgroup
+       %void = OpTypeVoid
+         %11 = OpTypeFunction %void %uint
+%_ptr_Function_uint = OpTypePointer Function %uint
+         %18 = OpConstantNull %uint
+     %uint_6 = OpConstant %uint 6
+       %bool = OpTypeBool
+%_ptr_Workgroup_int = OpTypePointer Workgroup %int
+         %36 = OpConstantNull %int
+     %uint_1 = OpConstant %uint 1
+   %uint_264 = OpConstant %uint 264
+%_ptr_Function__arr__arr_int_uint_3_uint_2 = OpTypePointer Function %_arr__arr_int_uint_3_uint_2
+         %45 = OpConstantNull %_arr__arr_int_uint_3_uint_2
+         %46 = OpTypeFunction %void
+ %main_inner = OpFunction %void None %11
+%local_invocation_index = OpFunctionParameter %uint
+         %15 = OpLabel
+        %idx = OpVariable %_ptr_Function_uint Function %18
+          %v = OpVariable %_ptr_Function__arr__arr_int_uint_3_uint_2 Function %45
+               OpStore %idx %local_invocation_index
+               OpBranch %19
+         %19 = OpLabel
+               OpLoopMerge %20 %21 None
+               OpBranch %22
+         %22 = OpLabel
+         %24 = OpLoad %uint %idx
+         %26 = OpULessThan %bool %24 %uint_6
+         %23 = OpLogicalNot %bool %26
+               OpSelectionMerge %28 None
+               OpBranchConditional %23 %29 %28
+         %29 = OpLabel
+               OpBranch %20
+         %28 = OpLabel
+         %30 = OpLoad %uint %idx
+         %31 = OpUDiv %uint %30 %uint_3
+         %32 = OpLoad %uint %idx
+         %33 = OpUMod %uint %32 %uint_3
+         %35 = OpAccessChain %_ptr_Workgroup_int %zero %31 %33
+               OpStore %35 %36
+               OpBranch %21
+         %21 = OpLabel
+         %37 = OpLoad %uint %idx
+         %39 = OpIAdd %uint %37 %uint_1
+               OpStore %idx %39
+               OpBranch %19
+         %20 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %42 = OpLoad %_arr__arr_int_uint_3_uint_2 %zero
+               OpStore %v %42
+               OpReturn
+               OpFunctionEnd
+       %main = OpFunction %void None %46
+         %48 = OpLabel
+         %50 = OpLoad %uint %local_invocation_index_1
+         %49 = OpFunctionCall %void %main_inner %50
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.wgsl b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..f3d6c3c
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/array_i32.wgsl.expected.wgsl
@@ -0,0 +1,6 @@
+var<workgroup> zero : array<array<i32, 3>, 2>;
+
+@compute @workgroup_size(1)
+fn main() {
+  var v = zero;
+}
diff --git a/test/tint/var/initialization/workgroup/array/i32.wgsl b/test/tint/var/initialization/workgroup/array/i32.wgsl
new file mode 100644
index 0000000..2b910b3
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl
@@ -0,0 +1,6 @@
+var<workgroup> zero : array<i32, 3>;
+
+@compute @workgroup_size(1)
+fn main() {
+    var v = zero;
+}
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.glsl b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.glsl
similarity index 84%
rename from test/tint/var/initialization/workgroup/array.wgsl.expected.glsl
rename to test/tint/var/initialization/workgroup/array/i32.wgsl.expected.glsl
index 0cb7390..b2191b1 100644
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.glsl
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.glsl
@@ -1,14 +1,15 @@
 #version 310 es
 
-shared int v[3];
+shared int zero[3];
 void tint_symbol(uint local_invocation_index) {
   {
     for(uint idx = local_invocation_index; (idx < 3u); idx = (idx + 1u)) {
       uint i = idx;
-      v[i] = 0;
+      zero[i] = 0;
     }
   }
   barrier();
+  int v[3] = zero;
 }
 
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.hlsl
similarity index 86%
rename from test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl
rename to test/tint/var/initialization/workgroup/array/i32.wgsl.expected.hlsl
index 21c4cab..15e697a 100644
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.hlsl
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.hlsl
@@ -1,4 +1,4 @@
-groupshared int v[3];
+groupshared int zero[3];
 
 struct tint_symbol_1 {
   uint local_invocation_index : SV_GroupIndex;
@@ -8,10 +8,11 @@
   {
     [loop] for(uint idx = local_invocation_index; (idx < 3u); idx = (idx + 1u)) {
       const uint i = idx;
-      v[i] = 0;
+      zero[i] = 0;
     }
   }
   GroupMemoryBarrierWithGroupSync();
+  int v[3] = zero;
 }
 
 [numthreads(1, 1, 1)]
diff --git a/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.msl b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.msl
new file mode 100644
index 0000000..5b98f4a
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.msl
@@ -0,0 +1,31 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+void tint_symbol_inner(uint local_invocation_index, threadgroup tint_array<int, 3>* const tint_symbol_1) {
+  for(uint idx = local_invocation_index; (idx < 3u); idx = (idx + 1u)) {
+    uint const i = idx;
+    (*(tint_symbol_1))[i] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  tint_array<int, 3> v = *(tint_symbol_1);
+}
+
+kernel void tint_symbol(uint local_invocation_index [[thread_index_in_threadgroup]]) {
+  threadgroup tint_array<int, 3> tint_symbol_2;
+  tint_symbol_inner(local_invocation_index, &(tint_symbol_2));
+  return;
+}
+
diff --git a/test/tint/var/initialization/workgroup/array.wgsl.expected.spvasm b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.spvasm
similarity index 79%
rename from test/tint/var/initialization/workgroup/array.wgsl.expected.spvasm
rename to test/tint/var/initialization/workgroup/array/i32.wgsl.expected.spvasm
index 97682d3..59c3e27 100644
--- a/test/tint/var/initialization/workgroup/array.wgsl.expected.spvasm
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.spvasm
@@ -1,17 +1,18 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 42
+; Bound: 46
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
                OpEntryPoint GLCompute %main "main" %local_invocation_index_1
                OpExecutionMode %main LocalSize 1 1 1
                OpName %local_invocation_index_1 "local_invocation_index_1"
-               OpName %v "v"
+               OpName %zero "zero"
                OpName %main_inner "main_inner"
                OpName %local_invocation_index "local_invocation_index"
                OpName %idx "idx"
+               OpName %v "v"
                OpName %main "main"
                OpDecorate %local_invocation_index_1 BuiltIn LocalInvocationIndex
                OpDecorate %_arr_int_uint_3 ArrayStride 4
@@ -22,7 +23,7 @@
      %uint_3 = OpConstant %uint 3
 %_arr_int_uint_3 = OpTypeArray %int %uint_3
 %_ptr_Workgroup__arr_int_uint_3 = OpTypePointer Workgroup %_arr_int_uint_3
-          %v = OpVariable %_ptr_Workgroup__arr_int_uint_3 Workgroup
+       %zero = OpVariable %_ptr_Workgroup__arr_int_uint_3 Workgroup
        %void = OpTypeVoid
           %9 = OpTypeFunction %void %uint
 %_ptr_Function_uint = OpTypePointer Function %uint
@@ -33,11 +34,14 @@
      %uint_1 = OpConstant %uint 1
      %uint_2 = OpConstant %uint 2
    %uint_264 = OpConstant %uint 264
-         %37 = OpTypeFunction %void
+%_ptr_Function__arr_int_uint_3 = OpTypePointer Function %_arr_int_uint_3
+         %40 = OpConstantNull %_arr_int_uint_3
+         %41 = OpTypeFunction %void
  %main_inner = OpFunction %void None %9
 %local_invocation_index = OpFunctionParameter %uint
          %13 = OpLabel
         %idx = OpVariable %_ptr_Function_uint Function %16
+          %v = OpVariable %_ptr_Function__arr_int_uint_3 Function %40
                OpStore %idx %local_invocation_index
                OpBranch %17
          %17 = OpLabel
@@ -53,7 +57,7 @@
                OpBranch %18
          %25 = OpLabel
          %27 = OpLoad %uint %idx
-         %29 = OpAccessChain %_ptr_Workgroup_int %v %27
+         %29 = OpAccessChain %_ptr_Workgroup_int %zero %27
                OpStore %29 %30
                OpBranch %19
          %19 = OpLabel
@@ -63,11 +67,13 @@
                OpBranch %17
          %18 = OpLabel
                OpControlBarrier %uint_2 %uint_2 %uint_264
+         %37 = OpLoad %_arr_int_uint_3 %zero
+               OpStore %v %37
                OpReturn
                OpFunctionEnd
-       %main = OpFunction %void None %37
-         %39 = OpLabel
-         %41 = OpLoad %uint %local_invocation_index_1
-         %40 = OpFunctionCall %void %main_inner %41
+       %main = OpFunction %void None %41
+         %43 = OpLabel
+         %45 = OpLoad %uint %local_invocation_index_1
+         %44 = OpFunctionCall %void %main_inner %45
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.wgsl b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.wgsl
new file mode 100644
index 0000000..8f7cdf6
--- /dev/null
+++ b/test/tint/var/initialization/workgroup/array/i32.wgsl.expected.wgsl
@@ -0,0 +1,6 @@
+var<workgroup> zero : array<i32, 3>;
+
+@compute @workgroup_size(1)
+fn main() {
+  var v = zero;
+}