diff --git a/BUILD.gn b/BUILD.gn
index 01684a9..547b74a 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -831,6 +831,7 @@
     "src/transform/bound_array_accessors_test.cc",
     "src/transform/emit_vertex_point_size_test.cc",
     "src/transform/first_index_offset_test.cc",
+    "src/transform/test_helper.h",
     "src/transform/vertex_pulling_test.cc",
     "src/type_determiner_test.cc",
     "src/validator/validator_control_block_test.cc",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1a7c6a4..adc89af 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -465,10 +465,6 @@
     scope_stack_test.cc
     symbol_table_test.cc
     symbol_test.cc
-    transform/emit_vertex_point_size_test.cc
-    transform/bound_array_accessors_test.cc
-    transform/first_index_offset_test.cc
-    transform/vertex_pulling_test.cc
     type_determiner_test.cc
     validator/validator_control_block_test.cc
     validator/validator_function_test.cc
@@ -656,6 +652,16 @@
     )
   endif()
 
+  if(${TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_WGSL_WRITER})
+    list(APPEND TINT_TEST_SRCS
+      transform/bound_array_accessors_test.cc
+      transform/emit_vertex_point_size_test.cc
+      transform/first_index_offset_test.cc
+      transform/test_helper.h
+      transform/vertex_pulling_test.cc
+    )
+  endif()
+
   if(${TINT_BUILD_MSL_WRITER})
     list(APPEND TINT_TEST_SRCS
       writer/msl/generator_impl_alias_type_test.cc
diff --git a/src/transform/bound_array_accessors_test.cc b/src/transform/bound_array_accessors_test.cc
index a3c148f..e7d70ce 100644
--- a/src/transform/bound_array_accessors_test.cc
+++ b/src/transform/bound_array_accessors_test.cc
@@ -14,918 +14,400 @@
 
 #include "src/transform/bound_array_accessors.h"
 
-#include <memory>
-#include <utility>
-
-#include "gtest/gtest.h"
-#include "src/ast/array_accessor_expression.h"
-#include "src/ast/binary_expression.h"
-#include "src/ast/block_statement.h"
-#include "src/ast/builder.h"
-#include "src/ast/call_expression.h"
-#include "src/ast/function.h"
-#include "src/ast/identifier_expression.h"
-#include "src/ast/module.h"
-#include "src/ast/scalar_constructor_expression.h"
-#include "src/ast/sint_literal.h"
-#include "src/ast/storage_class.h"
-#include "src/ast/type/array_type.h"
-#include "src/ast/type/f32_type.h"
-#include "src/ast/type/i32_type.h"
-#include "src/ast/type/matrix_type.h"
-#include "src/ast/type/pointer_type.h"
-#include "src/ast/type/u32_type.h"
-#include "src/ast/type/vector_type.h"
-#include "src/ast/type/void_type.h"
-#include "src/ast/type_constructor_expression.h"
-#include "src/ast/uint_literal.h"
-#include "src/ast/variable.h"
-#include "src/ast/variable_decl_statement.h"
-#include "src/diagnostic/formatter.h"
-#include "src/transform/manager.h"
-#include "src/type_determiner.h"
+#include "src/transform/test_helper.h"
 
 namespace tint {
 namespace transform {
 namespace {
 
-template <typename T = ast::Expression>
-T* FindVariable(ast::Module* mod, std::string name) {
-  if (auto* func = mod->FindFunctionBySymbol(mod->RegisterSymbol("func"))) {
-    for (auto* stmt : *func->body()) {
-      if (auto* decl = stmt->As<ast::VariableDeclStatement>()) {
-        if (auto* var = decl->variable()) {
-          if (var->name() == name) {
-            return As<T>(var->constructor());
-          }
-        }
-      }
-    }
-  }
-  return nullptr;
-}
-
-class BoundArrayAccessorsTest : public testing::Test {
- public:
-  ast::Module Transform(ast::Module in) {
-    TypeDeterminer td(&in);
-    if (!td.Determine()) {
-      error = "Type determination failed: " + td.error();
-      return {};
-    }
-
-    Manager manager;
-    manager.append(std::make_unique<BoundArrayAccessors>());
-    auto result = manager.Run(&in);
-
-    if (result.diagnostics.contains_errors()) {
-      error = "manager().Run() errored:\n" +
-              diag::Formatter().format(result.diagnostics);
-      return {};
-    }
-
-    return std::move(result.module);
-  }
-
-  std::string error;
-};
-
-struct ModuleBuilder : public ast::BuilderWithModule {
-  ast::Module Module() {
-    Build();
-    mod->AddFunction(Func("func", ast::VariableList{}, ty.void_, statements,
-                          ast::FunctionDecorationList{}));
-    return std::move(*mod);
-  }
-
- protected:
-  virtual void Build() = 0;
-  void OnVariableBuilt(ast::Variable* var) override {
-    statements.emplace_back(create<ast::VariableDeclStatement>(var));
-  }
-  ast::StatementList statements;
-};
+using BoundArrayAccessorsTest = TransformTest;
 
 TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
-  // var a : array<f32, 3>;
-  // const c : u32 =  1;
-  // const b : ptr<function, f32> = a[c]
-  //
-  //   -> const b : ptr<function, i32> = a[min(u32(c), 2)]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array<f32, 3>());
-      Const("c", ast::StorageClass::kFunction, ty.u32);
-      Const("b", ast::StorageClass::kFunction,
-            ty.pointer<f32>(ast::StorageClass::kFunction),
-            IndexAccessor("a", "c"), {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
+const c : u32 = 1u;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  const b : ptr<function, f32> = a[c];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
+const c : u32 = 1u;
 
-  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
+fn f() -> void {
+  const b : ptr<function, f32> = a[min(u32(c), 2u)];
+}
+)";
 
-  auto* idx = b->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_EQ(idx->params().size(), 2u);
-
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_TRUE(tc->values()[0]->Is<ast::IdentifierExpression>());
-  ASSERT_EQ(tc->values()[0]->As<ast::IdentifierExpression>()->name(), "c");
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
-  // var a : array<f32, 3>;
-  // var b : array<f32, 5>;
-  // var i : u32;
-  // var c : f32 = a[b[i]];
-  //
-  // -> var c : f32 = a[min(u32(b[min(u32(i), 4)]), 2)];
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array<f32, 3>());
-      Var("b", ast::StorageClass::kFunction, ty.array<f32, 5>());
-      Var("i", ast::StorageClass::kFunction, ty.u32);
-      Const("c", ast::StorageClass::kFunction, ty.f32,
-            IndexAccessor("a", IndexAccessor("b", "i")), {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
+var b : array<f32, 5>;
+var i : u32;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var c : f32 = a[ b[i] ];
+}
+)";
 
-  auto* c = FindVariable<ast::ArrayAccessorExpression>(&module, "c");
-  ASSERT_NE(c, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
+var b : array<f32, 5>;
+var i : u32;
 
-  ASSERT_TRUE(c->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(c->idx_expr()->Is<ast::CallExpression>());
+fn f() -> void {
+  var c : f32 = a[min(u32(b[min(u32(i), 4u)]), 2u)];
+}
+)";
 
-  auto* idx = c->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_EQ(idx->params().size(), 2u);
-
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-
-  auto* sub = tc->values()[0];
-  ASSERT_TRUE(sub->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(sub->As<ast::ArrayAccessorExpression>()
-                  ->idx_expr()
-                  ->Is<ast::CallExpression>());
-
-  auto* sub_idx = sub->As<ast::ArrayAccessorExpression>()
-                      ->idx_expr()
-                      ->As<ast::CallExpression>();
-  ASSERT_TRUE(sub_idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(sub_idx->func()->As<ast::IdentifierExpression>()->name(), "min");
-
-  ASSERT_TRUE(sub_idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(sub_idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  tc = sub_idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_TRUE(tc->values()[0]->Is<ast::IdentifierExpression>());
-  ASSERT_EQ(tc->values()[0]->As<ast::IdentifierExpression>()->name(), "i");
-
-  ASSERT_TRUE(sub_idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(sub_idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  auto* scalar = sub_idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 4u);
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(c->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(c->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Scalar) {
-  // var a : array<f32, 3>
-  // var b : f32 = a[1];
-  //
-  // -> var b : f32 = a[1];
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array(ty.f32, 3));
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", 1u),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[1];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
-  // var a : array<f32, 3>
-  // var c : u32;
-  // var b : f32 = a[c + 2 - 3]
-  //
-  // -> var b : f32 = a[min(u32(c + 2 - 3), 2)]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array<f32, 3>());
-      Var("c", ast::StorageClass::kFunction, ty.u32);
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor("a", Add("c", Sub(2u, 3u))), {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
+var c : u32;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[c + 2 - 3];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
+var c : u32;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
+fn f() -> void {
+  var b : f32 = a[min(u32(((c + 2) - 3)), 2u)];
+}
+)";
 
-  auto* idx = b->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_EQ(idx->params().size(), 2u);
-
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  auto* add = tc->values()[0]->As<ast::BinaryExpression>();
-  ASSERT_NE(add, nullptr);
-  ASSERT_EQ(add->op(), ast::BinaryOp::kAdd);
-  auto* add_lhs = add->lhs()->As<ast::IdentifierExpression>();
-  ASSERT_NE(add_lhs, nullptr);
-  ASSERT_EQ(add_lhs->name(), "c");
-  auto* add_rhs = add->rhs()->As<ast::BinaryExpression>();
-  ASSERT_NE(add_rhs, nullptr);
-  ASSERT_TRUE(add_rhs->lhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->lhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            2u);
-  ASSERT_TRUE(add_rhs->rhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->rhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            3u);
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Negative) {
-  // var a : array<f32, 3>
-  // var b : f32 = a[-1]
-  //
-  // -> var b : f32 = a[0]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array<f32, 3>());
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", -1),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[-1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[0];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 0);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_OutOfBounds) {
-  // var a : array<f32, 3>
-  // var b : f32 = a[3]
-  //
-  // -> var b : f32 = a[2]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.array<f32, 3>());
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", 3u),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : array<f32, 3>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[3];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : array<f32, 3>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[2];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Scalar) {
-  // var a : vec3<f32>
-  // var b : f32 = a[1];
-  //
-  // -> var b : f32 = a[1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.vec3<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", 1u),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : vec3<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : vec3<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[1];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
-  // var a : vec3<f32>
-  // var c : u32;
-  // var b : f32 = a[c + 2 - 3]
-  //
-  // -> var b : f32 = a[min(u32(c + 2 - 3), 2)]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.vec3<f32>());
-      Var("c", ast::StorageClass::kFunction, ty.u32);
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor("a", Add("c", Sub(2u, 3u))), {});
-    }
-  };
+  auto* src = R"(
+var a : vec3<f32>;
+var c : u32;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[c + 2 - 3];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : vec3<f32>;
+var c : u32;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
+fn f() -> void {
+  var b : f32 = a[min(u32(((c + 2) - 3)), 2u)];
+}
+)";
 
-  auto* idx = b->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_EQ(idx->params().size(), 2u);
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  auto* add = tc->values()[0]->As<ast::BinaryExpression>();
-  ASSERT_NE(add, nullptr);
-  auto* add_lhs = add->lhs()->As<ast::IdentifierExpression>();
-  ASSERT_NE(add_lhs, nullptr);
-  ASSERT_EQ(add_lhs->name(), "c");
-  auto* add_rhs = add->rhs()->As<ast::BinaryExpression>();
-  ASSERT_NE(add_rhs, nullptr);
-  ASSERT_TRUE(add_rhs->lhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->lhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            2u);
-  ASSERT_TRUE(add_rhs->rhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->rhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            3u);
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Negative) {
-  // var a : vec3<f32>
-  // var b : f32 = a[-1]
-  //
-  // -> var b : f32 = a[0]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.vec3<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", -1),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : vec3<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[-1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : vec3<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[0];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 0);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_OutOfBounds) {
-  // var a : vec3<f32>
-  // var b : f32 = a[3]
-  //
-  // -> var b : f32 = a[2]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.vec3<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32, IndexAccessor("a", 3u),
-          {});
-    }
-  };
+  auto* src = R"(
+var a : vec3<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[3];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : vec3<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
+fn f() -> void {
+  var b : f32 = a[2];
+}
+)";
 
-  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) {
-  // var a : mat3x2<f32>
-  // var b : f32 = a[2][1];
-  //
-  // -> var b : f32 = a[2][1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", 2u), 1u), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[2][1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[2][1];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
-  // var a : mat3x2<f32>
-  // var c : u32;
-  // var b : f32 = a[c + 2 - 3][1]
-  //
-  // -> var b : f32 = a[min(u32(c + 2 - 3), 2)][1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("c", ast::StorageClass::kFunction, ty.u32);
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", Add("c", Sub(2u, 3u))), 1u), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
+var c : u32;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[c + 2 - 3][1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
+var c : u32;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[min(u32(((c + 2) - 3)), 2u)][1];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::CallExpression>());
-  auto* idx = ary->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
-
-  ASSERT_EQ(idx->params().size(), 2u);
-
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  auto* add = tc->values()[0]->As<ast::BinaryExpression>();
-  ASSERT_NE(add, nullptr);
-  auto* add_lhs = add->lhs()->As<ast::IdentifierExpression>();
-  ASSERT_NE(add_lhs, nullptr);
-  ASSERT_EQ(add_lhs->name(), "c");
-  auto* add_rhs = add->rhs()->As<ast::BinaryExpression>();
-  ASSERT_NE(add_rhs, nullptr);
-  ASSERT_TRUE(add_rhs->lhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->lhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            2u);
-  ASSERT_TRUE(add_rhs->rhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->rhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            3u);
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
-  // var a : mat3x2<f32>
-  // var c : u32;
-  // var b : f32 = a[1][c + 2 - 3]
-  //
-  // -> var b : f32 = a[1][min(u32(c + 2 - 3), 1)]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("c", ast::StorageClass::kFunction, ty.u32);
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", 1u), Add("c", Sub(2u, 3u))), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
+var c : u32;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[1][c + 2 - 3];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
+var c : u32;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[1][min(u32(((c + 2) - 3)), 1u)];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
-  auto* idx = b->idx_expr()->As<ast::CallExpression>();
-  ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
-  EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
-
-  ASSERT_EQ(idx->params().size(), 2u);
-
-  ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
-  auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
-  EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
-  ASSERT_EQ(tc->values().size(), 1u);
-  auto* add = tc->values()[0]->As<ast::BinaryExpression>();
-  ASSERT_NE(add, nullptr);
-  auto* add_lhs = add->lhs()->As<ast::IdentifierExpression>();
-  ASSERT_NE(add_lhs, nullptr);
-  ASSERT_EQ(add_lhs->name(), "c");
-  auto* add_rhs = add->rhs()->As<ast::BinaryExpression>();
-  ASSERT_NE(add_rhs, nullptr);
-  ASSERT_TRUE(add_rhs->lhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->lhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            2u);
-  ASSERT_TRUE(add_rhs->rhs()->Is<ast::ScalarConstructorExpression>());
-  ASSERT_EQ(add_rhs->rhs()
-                ->As<ast::ScalarConstructorExpression>()
-                ->literal()
-                ->As<ast::UintLiteral>()
-                ->value(),
-            3u);
-
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
-  scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) {
-  // var a : mat3x2<f32>
-  // var b : f32 = a[-1][1]
-  //
-  // -> var b : f32 = a[0][1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", -1), 1), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[-1][1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[0][1];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 0);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 1);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) {
-  // var a : mat3x2<f32>
-  // var b : f32 = a[2][-1]
-  //
-  // -> var b : f32 = a[2][0]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", 2), -1), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[2][-1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[2][0];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 2);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::SintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::SintLiteral>()->value(), 0);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) {
-  // var a : mat3x2<f32>
-  // var b : f32 = a[5][1]
-  //
-  // -> var b : f32 = a[2][1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", 5u), 1u), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[5][1];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[2][1];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) {
-  // var a : mat3x2<f32>
-  // var b : f32 = a[2][5]
-  //
-  // -> var b : f32 = a[2][1]
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
-      Var("b", ast::StorageClass::kFunction, ty.f32,
-          IndexAccessor(IndexAccessor("a", 2u), 5u), {});
-    }
-  };
+  auto* src = R"(
+var a : mat3x2<f32>;
 
-  ast::Module module = Transform(Builder{}.Module());
-  ASSERT_EQ(error, "");
+fn f() -> void {
+  var b : f32 = a[2][5];
+}
+)";
 
-  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
-  ASSERT_NE(b, nullptr);
+  auto* expect = R"(
+var a : mat3x2<f32>;
 
-  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+fn f() -> void {
+  var b : f32 = a[2][1];
+}
+)";
 
-  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  auto got = Transform<BoundArrayAccessors>(src);
 
-  auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
-
-  ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
-
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
-  ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
-  EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
-
-  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::U32>());
+  EXPECT_EQ(expect, got);
 }
 
 // TODO(dsinclair): Implement when constant_id exists
@@ -934,7 +416,7 @@
   // var a : vec3<f32>
   // var b : f32 = a[idx]
   //
-  // ->var b : f32 =  a[min(u32(idx), 2)]
+  // ->var b : f32 = a[min(u32(idx), 2)]
 }
 
 // TODO(dsinclair): Implement when constant_id exists
diff --git a/src/transform/emit_vertex_point_size_test.cc b/src/transform/emit_vertex_point_size_test.cc
index c3c5f70..9a4a359 100644
--- a/src/transform/emit_vertex_point_size_test.cc
+++ b/src/transform/emit_vertex_point_size_test.cc
@@ -14,203 +14,106 @@
 
 #include "src/transform/emit_vertex_point_size.h"
 
-#include <memory>
-#include <utility>
-
-#include "gtest/gtest.h"
-#include "src/ast/builder.h"
-#include "src/ast/stage_decoration.h"
-#include "src/ast/variable_decl_statement.h"
-#include "src/demangler.h"
-#include "src/diagnostic/formatter.h"
-#include "src/transform/manager.h"
+#include "src/transform/test_helper.h"
 
 namespace tint {
 namespace transform {
 namespace {
 
-class EmitVertexPointSizeTest : public testing::Test {
- public:
-  Transform::Output GetTransform(ast::Module in) {
-    Manager manager;
-    manager.append(std::make_unique<EmitVertexPointSize>());
-    return manager.Run(&in);
-  }
-};
-
-struct ModuleBuilder : public ast::BuilderWithModule {
-  ModuleBuilder() {}
-
-  ast::Module Module() {
-    Build();
-    return std::move(*mod);
-  }
-
- protected:
-  virtual void Build() = 0;
-};
+using EmitVertexPointSizeTest = TransformTest;
 
 TEST_F(EmitVertexPointSizeTest, VertexStageBasic) {
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      mod->AddFunction(Func("non_entry_a", ast::VariableList{}, ty.void_,
-                            ast::StatementList{},
-                            ast::FunctionDecorationList{}));
+  auto* src = R"(
+fn non_entry_a() -> void {
+}
 
-      auto* entry =
-          Func("entry", ast::VariableList{}, ty.void_,
-               ast::StatementList{
-                   create<ast::VariableDeclStatement>(
-                       Var("builtin_assignments_should_happen_before_this",
-                           tint::ast::StorageClass::kFunction, ty.f32)),
-               },
-               ast::FunctionDecorationList{
-                   create<ast::StageDecoration>(ast::PipelineStage::kVertex),
-               });
-      mod->AddFunction(entry);
+[[stage(vertex)]]
+fn entry() -> void {
+  var builtin_assignments_should_happen_before_this : f32;
+}
 
-      mod->AddFunction(Func("non_entry_b", ast::VariableList{}, ty.void_,
-                            ast::StatementList{},
-                            ast::FunctionDecorationList{}));
-    }
-  };
-
-  auto result = GetTransform(Builder{}.Module());
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto* expected = R"(Module{
-  Variable{
-    Decorations{
-      BuiltinDecoration{pointsize}
-    }
-    tint_pointsize
-    out
-    __f32
-  }
-  Function non_entry_a -> __void
-  ()
-  {
-  }
-  Function entry -> __void
-  StageDecoration{vertex}
-  ()
-  {
-    Assignment{
-      Identifier[__ptr_out__f32]{tint_pointsize}
-      ScalarConstructor[__f32]{1.000000}
-    }
-    VariableDeclStatement{
-      Variable{
-        builtin_assignments_should_happen_before_this
-        function
-        __f32
-      }
-    }
-  }
-  Function non_entry_b -> __void
-  ()
-  {
-  }
+fn non_entry_b() -> void {
 }
 )";
-  EXPECT_EQ(expected,
-            Demangler().Demangle(result.module, result.module.to_str()));
+
+  auto* expect = R"(
+[[builtin(pointsize)]] var<out> tint_pointsize : f32;
+
+fn non_entry_a() -> void {
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  tint_pointsize = 1.0;
+  var builtin_assignments_should_happen_before_this : f32;
+}
+
+fn non_entry_b() -> void {
+}
+)";
+
+  auto got = Transform<EmitVertexPointSize>(src);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      mod->AddFunction(Func("non_entry_a", ast::VariableList{}, ty.void_,
-                            ast::StatementList{},
-                            ast::FunctionDecorationList{}));
+  auto* src = R"(
+fn non_entry_a() -> void {
+}
 
-      mod->AddFunction(
-          Func("entry", ast::VariableList{}, ty.void_, ast::StatementList{},
-               ast::FunctionDecorationList{
-                   create<ast::StageDecoration>(ast::PipelineStage::kVertex),
-               }));
+[[stage(vertex)]]
+fn entry() -> void {
+}
 
-      mod->AddFunction(Func("non_entry_b", ast::VariableList{}, ty.void_,
-                            ast::StatementList{},
-                            ast::FunctionDecorationList{}));
-    }
-  };
-
-  auto result = GetTransform(Builder{}.Module());
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto* expected = R"(Module{
-  Variable{
-    Decorations{
-      BuiltinDecoration{pointsize}
-    }
-    tint_pointsize
-    out
-    __f32
-  }
-  Function non_entry_a -> __void
-  ()
-  {
-  }
-  Function entry -> __void
-  StageDecoration{vertex}
-  ()
-  {
-    Assignment{
-      Identifier[__ptr_out__f32]{tint_pointsize}
-      ScalarConstructor[__f32]{1.000000}
-    }
-  }
-  Function non_entry_b -> __void
-  ()
-  {
-  }
+fn non_entry_b() -> void {
 }
 )";
-  EXPECT_EQ(expected,
-            Demangler().Demangle(result.module, result.module.to_str()));
+
+  auto* expect = R"(
+[[builtin(pointsize)]] var<out> tint_pointsize : f32;
+
+fn non_entry_a() -> void {
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  tint_pointsize = 1.0;
+}
+
+fn non_entry_b() -> void {
+}
+)";
+
+  auto got = Transform<EmitVertexPointSize>(src);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(EmitVertexPointSizeTest, NonVertexStage) {
-  struct Builder : ModuleBuilder {
-    void Build() override {
-      auto* fragment_entry = Func(
-          "fragment_entry", ast::VariableList{}, ty.void_, ast::StatementList{},
-          ast::FunctionDecorationList{
-              create<ast::StageDecoration>(ast::PipelineStage::kFragment),
-          });
-      mod->AddFunction(fragment_entry);
+  auto* src = R"(
+[[stage(fragment)]]
+fn fragment_entry() -> void {
+}
 
-      auto* compute_entry = Func(
-          "compute_entry", ast::VariableList{}, ty.void_, ast::StatementList{},
-          ast::FunctionDecorationList{
-              create<ast::StageDecoration>(ast::PipelineStage::kCompute),
-          });
-      mod->AddFunction(compute_entry);
-    }
-  };
-
-  auto result = GetTransform(Builder{}.Module());
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto* expected = R"(Module{
-  Function fragment_entry -> __void
-  StageDecoration{fragment}
-  ()
-  {
-  }
-  Function compute_entry -> __void
-  StageDecoration{compute}
-  ()
-  {
-  }
+[[stage(compute)]]
+fn compute_entry() -> void {
 }
 )";
-  EXPECT_EQ(expected,
-            Demangler().Demangle(result.module, result.module.to_str()));
+
+  auto* expect = R"(
+[[stage(fragment)]]
+fn fragment_entry() -> void {
+}
+
+[[stage(compute)]]
+fn compute_entry() -> void {
+}
+)";
+
+  auto got = Transform<EmitVertexPointSize>(src);
+
+  EXPECT_EQ(expect, got);
 }
 
 }  // namespace
diff --git a/src/transform/first_index_offset_test.cc b/src/transform/first_index_offset_test.cc
index 094df6d..c739810 100644
--- a/src/transform/first_index_offset_test.cc
+++ b/src/transform/first_index_offset_test.cc
@@ -15,413 +15,223 @@
 #include "src/transform/first_index_offset.h"
 
 #include <memory>
-#include <string>
 #include <utility>
+#include <vector>
 
-#include "gtest/gtest.h"
-#include "src/ast/block_statement.h"
-#include "src/ast/builder.h"
-#include "src/ast/builtin.h"
-#include "src/ast/builtin_decoration.h"
-#include "src/ast/call_expression.h"
-#include "src/ast/call_statement.h"
-#include "src/ast/function.h"
-#include "src/ast/identifier_expression.h"
-#include "src/ast/module.h"
-#include "src/ast/return_statement.h"
-#include "src/ast/storage_class.h"
-#include "src/ast/type/u32_type.h"
-#include "src/ast/variable.h"
-#include "src/ast/variable_decoration.h"
-#include "src/demangler.h"
-#include "src/diagnostic/formatter.h"
-#include "src/source.h"
-#include "src/transform/manager.h"
+#include "src/transform/test_helper.h"
 
 namespace tint {
 namespace transform {
 namespace {
 
-class FirstIndexOffsetTest : public testing::Test {};
-
-struct ModuleBuilder : public ast::BuilderWithModule {
-  ast::Module Module() {
-    Build();
-    return std::move(*mod);
-  }
-
- protected:
-  void AddBuiltinInput(const std::string& name, ast::Builtin builtin) {
-    mod->AddGlobalVariable(Var(name, ast::StorageClass::kInput, ty.u32, nullptr,
-                               {create<ast::BuiltinDecoration>(builtin)}));
-  }
-
-  ast::Function* AddFunction(const std::string& name,
-                             ast::StatementList stmts) {
-    auto* func = Func(name, ast::VariableList{}, ty.u32, stmts,
-                      ast::FunctionDecorationList{});
-    mod->AddFunction(func);
-    return func;
-  }
-
-  virtual void Build() = 0;
-};
+using FirstIndexOffsetTest = TransformTest;
 
 TEST_F(FirstIndexOffsetTest, Error_AlreadyTransformed) {
-  struct Builder : public ModuleBuilder {
-    void Build() override {
-      AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
-      AddFunction("test", {create<ast::ReturnStatement>(Expr("vert_idx"))});
-    }
-  };
+  auto* src = R"(
+[[builtin(vertex_idx)]] var<in> vert_idx : u32;
 
-  Manager manager;
-  manager.append(std::make_unique<FirstIndexOffset>(0, 0));
-  manager.append(std::make_unique<FirstIndexOffset>(1, 1));
+fn test() -> u32 {
+  return vert_idx;
+}
 
-  auto module = Builder{}.Module();
-  auto result = manager.Run(&module);
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
+}
+)";
 
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
+  auto* expect = R"(manager().Run() errored:
+error: First index offset transform has already been applied.)";
 
-  ASSERT_EQ(diag::Formatter().format(result.diagnostics),
-            "error: First index offset transform has already been applied.");
+  std::vector<std::unique_ptr<transform::Transform>> transforms;
+  transforms.emplace_back(std::make_unique<FirstIndexOffset>(0, 0));
+  transforms.emplace_back(std::make_unique<FirstIndexOffset>(1, 1));
+
+  auto got = Transform(src, std::move(transforms));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(FirstIndexOffsetTest, EmptyModule) {
-  Manager manager;
-  manager.append(std::make_unique<FirstIndexOffset>(0, 0));
+  auto* src = "";
+  auto* expect = "";
 
-  ast::Module module;
-  auto result = manager.Run(&module);
+  auto got = Transform<FirstIndexOffset>(src, 0, 0);
 
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
-
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto got = result.module.to_str();
-  auto* expected = "Module{\n}\n";
-  EXPECT_EQ(got, expected);
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex) {
-  struct Builder : public ModuleBuilder {
-    void Build() override {
-      AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
-      AddFunction("test", {create<ast::ReturnStatement>(Expr("vert_idx"))});
-    }
-  };
+  auto* src = R"(
+[[builtin(vertex_idx)]] var<in> vert_idx : u32;
 
-  Manager manager;
-  manager.append(std::make_unique<FirstIndexOffset>(1, 2));
+fn test() -> u32 {
+  return vert_idx;
+}
 
-  auto module = Builder{}.Module();
-  auto result = manager.Run(&module);
-
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
-
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto got = result.module.to_str();
-  auto* expected =
-      R"(Module{
-  TintFirstIndexOffsetData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] tint_first_vertex_index: __u32}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    tint_first_index_offset_vert_idx
-    in
-    __u32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{1}
-      SetDecoration{2}
-    }
-    tint_first_index_data
-    uniform
-    __struct_TintFirstIndexOffsetData
-  }
-  Function test -> __u32
-  ()
-  {
-    VariableDeclStatement{
-      VariableConst{
-        vert_idx
-        none
-        __u32
-        {
-          Binary[__u32]{
-            Identifier[__ptr_in__u32]{tint_first_index_offset_vert_idx}
-            add
-            MemberAccessor[__ptr_uniform__u32]{
-              Identifier[__ptr_uniform__struct_TintFirstIndexOffsetData]{tint_first_index_data}
-              Identifier[not set]{tint_first_vertex_index}
-            }
-          }
-        }
-      }
-    }
-    Return{
-      {
-        Identifier[__u32]{vert_idx}
-      }
-    }
-  }
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
 }
 )";
-  EXPECT_EQ(Demangler().Demangle(result.module, got), expected);
+
+  auto* expect = R"(
+[[block]]
+struct TintFirstIndexOffsetData {
+  [[offset(0)]]
+  tint_first_vertex_index : u32;
+};
+
+[[builtin(vertex_idx)]] var<in> tint_first_index_offset_vert_idx : u32;
+[[binding(1), set(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData;
+
+fn test() -> u32 {
+  const vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index);
+  return vert_idx;
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
+}
+)";
+
+  auto got = Transform<FirstIndexOffset>(src, 1, 2);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) {
-  struct Builder : public ModuleBuilder {
-    void Build() override {
-      AddBuiltinInput("inst_idx", ast::Builtin::kInstanceIdx);
-      AddFunction("test", {create<ast::ReturnStatement>(Expr("inst_idx"))});
-    }
-  };
+  auto* src = R"(
+[[builtin(instance_idx)]] var<in> inst_idx : u32;
 
-  Manager manager;
-  manager.append(std::make_unique<FirstIndexOffset>(1, 7));
+fn test() -> u32 {
+  return inst_idx;
+}
 
-  auto module = Builder{}.Module();
-  auto result = manager.Run(&module);
-
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
-
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto got = result.module.to_str();
-  auto* expected = R"(Module{
-  TintFirstIndexOffsetData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] tint_first_instance_index: __u32}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{instance_idx}
-    }
-    tint_first_index_offset_inst_idx
-    in
-    __u32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{1}
-      SetDecoration{7}
-    }
-    tint_first_index_data
-    uniform
-    __struct_TintFirstIndexOffsetData
-  }
-  Function test -> __u32
-  ()
-  {
-    VariableDeclStatement{
-      VariableConst{
-        inst_idx
-        none
-        __u32
-        {
-          Binary[__u32]{
-            Identifier[__ptr_in__u32]{tint_first_index_offset_inst_idx}
-            add
-            MemberAccessor[__ptr_uniform__u32]{
-              Identifier[__ptr_uniform__struct_TintFirstIndexOffsetData]{tint_first_index_data}
-              Identifier[not set]{tint_first_instance_index}
-            }
-          }
-        }
-      }
-    }
-    Return{
-      {
-        Identifier[__u32]{inst_idx}
-      }
-    }
-  }
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
 }
 )";
-  EXPECT_EQ(Demangler().Demangle(result.module, got), expected);
+
+  auto* expect = R"(
+[[block]]
+struct TintFirstIndexOffsetData {
+  [[offset(0)]]
+  tint_first_instance_index : u32;
+};
+
+[[builtin(instance_idx)]] var<in> tint_first_index_offset_inst_idx : u32;
+[[binding(1), set(7)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData;
+
+fn test() -> u32 {
+  const inst_idx : u32 = (tint_first_index_offset_inst_idx + tint_first_index_data.tint_first_instance_index);
+  return inst_idx;
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
+}
+)";
+
+  auto got = Transform<FirstIndexOffset>(src, 1, 7);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex) {
-  struct Builder : public ModuleBuilder {
-    void Build() override {
-      AddBuiltinInput("inst_idx", ast::Builtin::kInstanceIdx);
-      AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
-      AddFunction("test", {
-                              create<ast::ReturnStatement>(Expr(1u)),
-                          });
-    }
-  };
+  auto* src = R"(
+[[builtin(instance_idx)]] var<in> instance_idx : u32;
+[[builtin(vertex_idx)]] var<in> vert_idx : u32;
 
-  auto transform = std::make_unique<FirstIndexOffset>(1, 7);
-  auto* transform_ptr = transform.get();
+fn test() -> u32 {
+  return instance_idx + vert_idx;
+}
 
-  Manager manager;
-  manager.append(std::move(transform));
-
-  auto module = Builder{}.Module();
-  auto result = manager.Run(&module);
-
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
-
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto got = result.module.to_str();
-  auto* expected = R"(Module{
-  TintFirstIndexOffsetData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] tint_first_vertex_index: __u32}
-    StructMember{[[ offset 4 ]] tint_first_instance_index: __u32}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{instance_idx}
-    }
-    tint_first_index_offset_inst_idx
-    in
-    __u32
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    tint_first_index_offset_vert_idx
-    in
-    __u32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{1}
-      SetDecoration{7}
-    }
-    tint_first_index_data
-    uniform
-    __struct_TintFirstIndexOffsetData
-  }
-  Function test -> __u32
-  ()
-  {
-    Return{
-      {
-        ScalarConstructor[__u32]{1}
-      }
-    }
-  }
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
 }
 )";
-  EXPECT_EQ(Demangler().Demangle(result.module, got), expected);
 
-  EXPECT_TRUE(transform_ptr->HasVertexIndex());
-  EXPECT_EQ(transform_ptr->GetFirstVertexOffset(), 0u);
+  auto* expect = R"(
+[[block]]
+struct TintFirstIndexOffsetData {
+  [[offset(0)]]
+  tint_first_vertex_index : u32;
+  [[offset(4)]]
+  tint_first_instance_index : u32;
+};
 
-  EXPECT_TRUE(transform_ptr->HasInstanceIndex());
-  EXPECT_EQ(transform_ptr->GetFirstInstanceOffset(), 4u);
+[[builtin(instance_idx)]] var<in> tint_first_index_offset_instance_idx : u32;
+[[builtin(vertex_idx)]] var<in> tint_first_index_offset_vert_idx : u32;
+[[binding(1), set(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData;
+
+fn test() -> u32 {
+  const instance_idx : u32 = (tint_first_index_offset_instance_idx + tint_first_index_data.tint_first_instance_index);
+  const vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index);
+  return (instance_idx + vert_idx);
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  test();
+}
+)";
+
+  auto got = Transform<FirstIndexOffset>(src, 1, 2);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(FirstIndexOffsetTest, NestedCalls) {
-  struct Builder : public ModuleBuilder {
-    void Build() override {
-      AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
-      AddFunction("func1", {create<ast::ReturnStatement>(Expr("vert_idx"))});
-      AddFunction("func2", {create<ast::ReturnStatement>(Call("func1"))});
-    }
-  };
+  auto* src = R"(
+[[builtin(vertex_idx)]] var<in> vert_idx : u32;
 
-  auto transform = std::make_unique<FirstIndexOffset>(2, 2);
+fn func1() -> u32 {
+  return vert_idx;
+}
 
-  Manager manager;
-  manager.append(std::move(transform));
+fn func2() -> u32 {
+  return func1();
+}
 
-  auto module = Builder{}.Module();
-  auto result = manager.Run(&module);
-
-  // Release the source module to ensure there's no uncloned data in result
-  { auto tmp = std::move(module); }
-
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  auto got = result.module.to_str();
-  auto* expected = R"(Module{
-  TintFirstIndexOffsetData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] tint_first_vertex_index: __u32}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    tint_first_index_offset_vert_idx
-    in
-    __u32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{2}
-      SetDecoration{2}
-    }
-    tint_first_index_data
-    uniform
-    __struct_TintFirstIndexOffsetData
-  }
-  Function func1 -> __u32
-  ()
-  {
-    VariableDeclStatement{
-      VariableConst{
-        vert_idx
-        none
-        __u32
-        {
-          Binary[__u32]{
-            Identifier[__ptr_in__u32]{tint_first_index_offset_vert_idx}
-            add
-            MemberAccessor[__ptr_uniform__u32]{
-              Identifier[__ptr_uniform__struct_TintFirstIndexOffsetData]{tint_first_index_data}
-              Identifier[not set]{tint_first_vertex_index}
-            }
-          }
-        }
-      }
-    }
-    Return{
-      {
-        Identifier[__u32]{vert_idx}
-      }
-    }
-  }
-  Function func2 -> __u32
-  ()
-  {
-    Return{
-      {
-        Call[__u32]{
-          Identifier[__u32]{func1}
-          (
-          )
-        }
-      }
-    }
-  }
+[[stage(vertex)]]
+fn entry() -> void {
+  func2();
 }
 )";
-  EXPECT_EQ(Demangler().Demangle(result.module, got), expected);
+
+  auto* expect = R"(
+[[block]]
+struct TintFirstIndexOffsetData {
+  [[offset(0)]]
+  tint_first_vertex_index : u32;
+};
+
+[[builtin(vertex_idx)]] var<in> tint_first_index_offset_vert_idx : u32;
+[[binding(1), set(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData;
+
+fn func1() -> u32 {
+  const vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index);
+  return vert_idx;
+}
+
+fn func2() -> u32 {
+  return func1();
+}
+
+[[stage(vertex)]]
+fn entry() -> void {
+  func2();
+}
+)";
+
+  auto got = Transform<FirstIndexOffset>(src, 1, 2);
+
+  EXPECT_EQ(expect, got);
 }
 
 }  // namespace
diff --git a/src/transform/test_helper.h b/src/transform/test_helper.h
new file mode 100644
index 0000000..269d8a9
--- /dev/null
+++ b/src/transform/test_helper.h
@@ -0,0 +1,115 @@
+// 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_TRANSFORM_TEST_HELPER_H_
+#define SRC_TRANSFORM_TEST_HELPER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "src/reader/wgsl/parser.h"
+#include "src/transform/manager.h"
+#include "src/type_determiner.h"
+#include "src/writer/wgsl/generator.h"
+
+namespace tint {
+namespace transform {
+
+/// Helper class for testing transforms
+class TransformTest : public testing::Test {
+ public:
+  /// Transforms and returns the WGSL source `in`, transformed using
+  /// `transforms`.
+  /// @param in the input WGSL source
+  /// @param transforms the list of transforms to apply
+  /// @return the transformed WGSL output
+  std::string Transform(
+      std::string in,
+      std::vector<std::unique_ptr<transform::Transform>> transforms) {
+    Source::File file("test", in);
+    reader::wgsl::Parser parser(&file);
+    if (!parser.Parse()) {
+      return "WGSL reader failed:\n" + parser.error();
+    }
+
+    auto module = parser.module();
+    TypeDeterminer td(&module);
+    if (!td.Determine()) {
+      return "Type determination failed:\n" + td.error();
+    }
+
+    Manager manager;
+    for (auto& transform : transforms) {
+      manager.append(std::move(transform));
+    }
+    auto result = manager.Run(&module);
+
+    if (result.diagnostics.contains_errors()) {
+      return "manager().Run() errored:\n" +
+             diag::Formatter().format(result.diagnostics);
+    }
+
+    // Release the source module to ensure there's no uncloned data in result
+    { auto tmp = std::move(module); }
+
+    writer::wgsl::Generator generator(std::move(result.module));
+    if (!generator.Generate()) {
+      return "WGSL writer failed:\n" + generator.error();
+    }
+
+    auto res = generator.result();
+    if (res.empty()) {
+      return res;
+    }
+    // The WGSL sometimes has two trailing newlines. Strip them
+    while (res.back() == '\n') {
+      res.pop_back();
+    }
+    if (res.empty()) {
+      return res;
+    }
+    return "\n" + res + "\n";
+  }
+
+  /// Transforms and returns the WGSL source `in`, transformed using
+  /// `transform`.
+  /// @param transform the transform to apply
+  /// @param in the input WGSL source
+  /// @return the transformed WGSL output
+  std::string Transform(std::string in,
+                        std::unique_ptr<transform::Transform> transform) {
+    std::vector<std::unique_ptr<transform::Transform>> transforms;
+    transforms.emplace_back(std::move(transform));
+    return Transform(std::move(in), std::move(transforms));
+  }
+
+  /// Transforms and returns the WGSL source `in`, transformed using
+  /// a transform of type `TRANSFORM`.
+  /// @param in the input WGSL source
+  /// @param args the TRANSFORM constructor arguments
+  /// @return the transformed WGSL output
+  template <typename TRANSFORM, typename... ARGS>
+  std::string Transform(std::string in, ARGS&&... args) {
+    return Transform(std::move(in),
+                     std::make_unique<TRANSFORM>(std::forward<ARGS>(args)...));
+  }
+};
+
+}  // namespace transform
+}  // namespace tint
+
+#endif  // SRC_TRANSFORM_TEST_HELPER_H_
diff --git a/src/transform/vertex_pulling_test.cc b/src/transform/vertex_pulling_test.cc
index 129a4f9..87e9a0c 100644
--- a/src/transform/vertex_pulling_test.cc
+++ b/src/transform/vertex_pulling_test.cc
@@ -16,1008 +16,369 @@
 
 #include <utility>
 
-#include "gtest/gtest.h"
-#include "src/ast/builder.h"
-#include "src/ast/function.h"
-#include "src/ast/pipeline_stage.h"
-#include "src/ast/stage_decoration.h"
-#include "src/ast/type/array_type.h"
-#include "src/ast/type/f32_type.h"
-#include "src/ast/type/i32_type.h"
-#include "src/ast/type/void_type.h"
-#include "src/demangler.h"
-#include "src/diagnostic/formatter.h"
-#include "src/transform/manager.h"
-#include "src/type_determiner.h"
-#include "src/validator/validator.h"
+#include "src/transform/test_helper.h"
 
 namespace tint {
 namespace transform {
 namespace {
 
-class VertexPullingHelper : public ast::BuilderWithModule {
- public:
-  VertexPullingHelper() {
-    manager_ = std::make_unique<Manager>();
-    auto transform = std::make_unique<VertexPulling>();
-    transform_ = transform.get();
-    manager_->append(std::move(transform));
-  }
-
-  // Create basic module with an entry point and vertex function
-  void InitBasicModule() {
-    auto* func =
-        Func("main", ast::VariableList{}, ty.void_, ast::StatementList{},
-             ast::FunctionDecorationList{
-                 create<ast::StageDecoration>(ast::PipelineStage::kVertex)});
-
-    mod->AddFunction(func);
-  }
-
-  // Set up the transformation, after building the module
-  void InitTransform(VertexStateDescriptor vertex_state) {
-    EXPECT_TRUE(mod->IsValid());
-
-    TypeDeterminer td(mod);
-    EXPECT_TRUE(td.Determine());
-
-    transform_->SetVertexState(vertex_state);
-    transform_->SetEntryPoint("main");
-  }
-
-  // Inserts a variable which will be converted to vertex pulling
-  void AddVertexInputVariable(uint32_t location,
-                              std::string name,
-                              ast::type::Type* type) {
-    auto* var = Var(name, ast::StorageClass::kInput, type, nullptr,
-                    ast::VariableDecorationList{
-                        create<ast::LocationDecoration>(location),
-                    });
-
-    mod->AddGlobalVariable(var);
-  }
-
-  Manager* manager() { return manager_.get(); }
-  VertexPulling* transform() { return transform_; }
-
- private:
-  std::unique_ptr<Manager> manager_;
-  VertexPulling* transform_;
-};
-
-class VertexPullingTest : public VertexPullingHelper, public testing::Test {};
+using VertexPullingTest = TransformTest;
 
 TEST_F(VertexPullingTest, Error_NoVertexState) {
-  auto result = manager()->Run(mod);
-  EXPECT_TRUE(result.diagnostics.contains_errors());
-  EXPECT_EQ(diag::Formatter().format(result.diagnostics),
-            "error: SetVertexState not called");
+  auto* src = R"(
+[[stage(vertex)]]
+fn main() -> void {}
+)";
+
+  auto* expect = R"(manager().Run() errored:
+error: SetVertexState not called)";
+
+  auto got = Transform<VertexPulling>(src);
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, Error_NoEntryPoint) {
-  transform()->SetVertexState({});
-  auto result = manager()->Run(mod);
-  EXPECT_TRUE(result.diagnostics.contains_errors());
-  EXPECT_EQ(diag::Formatter().format(result.diagnostics),
-            "error: Vertex stage entry point not found");
+  auto* src = "";
+
+  auto* expect = R"(manager().Run() errored:
+error: Vertex stage entry point not found)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState({});
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, Error_InvalidEntryPoint) {
-  InitBasicModule();
-  InitTransform({});
-  transform()->SetEntryPoint("_");
+  auto* src = R"(
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  auto result = manager()->Run(mod);
-  EXPECT_TRUE(result.diagnostics.contains_errors());
-  EXPECT_EQ(diag::Formatter().format(result.diagnostics),
-            "error: Vertex stage entry point not found");
+  auto* expect = R"(manager().Run() errored:
+error: Vertex stage entry point not found)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState({});
+  transform->SetEntryPoint("_");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, Error_EntryPointWrongStage) {
-  auto* func =
-      Func("main", ast::VariableList{}, ty.void_, ast::StatementList{},
-           ast::FunctionDecorationList{
-               create<ast::StageDecoration>(ast::PipelineStage::kFragment),
-           });
-  mod->AddFunction(func);
+  auto* src = R"(
+[[stage(fragment)]]
+fn main() -> void {}
+)";
 
-  InitTransform({});
-  auto result = manager()->Run(mod);
-  EXPECT_TRUE(result.diagnostics.contains_errors());
-  EXPECT_EQ(diag::Formatter().format(result.diagnostics),
-            "error: Vertex stage entry point not found");
+  auto* expect = R"(manager().Run() errored:
+error: Vertex stage entry point not found)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState({});
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, BasicModule) {
-  InitBasicModule();
-  InitTransform({});
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+  auto* src = R"(
+[[stage(vertex)]]
+fn main() -> void {}
+)";
+
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
+
+[[stage(vertex)]]
+fn main() -> void {
+  {
+    var _tint_pulling_pos : i32;
+  }
+}
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState({});
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, OneAttribute) {
-  InitBasicModule();
+  auto* src = R"(
+[[location(0)]] var<in> var_a : f32;
 
-  AddVertexInputVariable(0, "var_a", ty.f32);
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  InitTransform({{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
 
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+[[builtin(vertex_idx)]] var<in> _tint_pulling_vertex_index : i32;
+[[binding(0), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+var<private> var_a : f32;
 
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    _tint_pulling_vertex_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __f32
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
+[[stage(vertex)]]
+fn main() -> void {
   {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{4}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_a}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-    }
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 4u) + 0u);
+    var_a = bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[(_tint_pulling_pos / 4u)]);
   }
 }
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
+      {{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, OneInstancedAttribute) {
-  InitBasicModule();
+  auto* src = R"(
+[[location(0)]] var<in> var_a : f32;
 
-  AddVertexInputVariable(0, "var_a", ty.f32);
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  InitTransform(
-      {{{4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 0}}}}});
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
 
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+[[builtin(instance_idx)]] var<in> _tint_pulling_instance_index : i32;
+[[binding(0), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+var<private> var_a : f32;
 
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{instance_idx}
-    }
-    _tint_pulling_instance_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __f32
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
+[[stage(vertex)]]
+fn main() -> void {
   {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_instance_index}
-            multiply
-            ScalarConstructor[__u32]{4}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_a}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-    }
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((_tint_pulling_instance_index * 4u) + 0u);
+    var_a = bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[(_tint_pulling_pos / 4u)]);
   }
 }
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
+      {{{4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 0}}}}});
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
-  InitBasicModule();
+  auto* src = R"(
+[[location(0)]] var<in> var_a : f32;
 
-  AddVertexInputVariable(0, "var_a", ty.f32);
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  InitTransform({{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
-  transform()->SetPullingBufferBindingSet(5);
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
 
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+[[builtin(vertex_idx)]] var<in> _tint_pulling_vertex_index : i32;
+[[binding(0), set(5)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+var<private> var_a : f32;
 
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    _tint_pulling_vertex_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{5}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __f32
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
+[[stage(vertex)]]
+fn main() -> void {
   {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{4}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_a}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-    }
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 4u) + 0u);
+    var_a = bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[(_tint_pulling_pos / 4u)]);
   }
 }
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
+      {{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
+  transform->SetPullingBufferBindingSet(5);
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 // We expect the transform to use an existing builtin variables if it finds them
 TEST_F(VertexPullingTest, ExistingVertexIndexAndInstanceIndex) {
-  InitBasicModule();
+  auto* src = R"(
+[[location(0)]] var<in> var_a : f32;
+[[location(1)]] var<in> var_b : f32;
+[[builtin(vertex_idx)]] var<in> custom_vertex_index : i32;
+[[builtin(instance_idx)]] var<in> custom_instance_index : i32;
 
-  AddVertexInputVariable(0, "var_a", ty.f32);
-  AddVertexInputVariable(1, "var_b", ty.f32);
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  mod->AddGlobalVariable(
-      Var("custom_vertex_index", ast::StorageClass::kInput, ty.i32, nullptr,
-          ast::VariableDecorationList{
-              create<ast::BuiltinDecoration>(ast::Builtin::kVertexIdx),
-          }));
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
 
-  mod->AddGlobalVariable(
-      Var("custom_instance_index", ast::StorageClass::kInput, ty.i32, nullptr,
-          ast::VariableDecorationList{
-              create<ast::BuiltinDecoration>(ast::Builtin::kInstanceIdx),
-          }));
+[[binding(0), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+[[binding(1), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_1 : TintVertexData;
+var<private> var_a : f32;
+var<private> var_b : f32;
+[[builtin(vertex_idx)]] var<in> custom_vertex_index : i32;
+[[builtin(instance_idx)]] var<in> custom_instance_index : i32;
 
-  InitTransform(
-      {{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}},
-        {4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 1}}}}});
-
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
-
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{1}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_1
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __f32
-  }
-  Variable{
-    var_b
-    private
-    __f32
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    custom_vertex_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{instance_idx}
-    }
-    custom_instance_index
-    in
-    __i32
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
+[[stage(vertex)]]
+fn main() -> void {
   {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{custom_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{4}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_a}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{custom_instance_index}
-            multiply
-            ScalarConstructor[__u32]{4}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_b}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_1}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-    }
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((custom_vertex_index * 4u) + 0u);
+    var_a = bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[(_tint_pulling_pos / 4u)]);
+    _tint_pulling_pos = ((custom_instance_index * 4u) + 0u);
+    var_b = bitcast<f32>(_tint_pulling_vertex_buffer_1._tint_vertex_data[(_tint_pulling_pos / 4u)]);
   }
 }
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
+      {{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}},
+        {4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 1}}}}});
+  transform->SetEntryPoint("main");
+
+  auto got = Transform(src, std::move(transform));
+
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
-  InitBasicModule();
+  auto* src = R"(
+[[location(0)]] var<in> var_a : f32;
+[[location(1)]] var<in> var_b : array<f32, 4>;
 
-  AddVertexInputVariable(0, "var_a", ty.f32);
-  AddVertexInputVariable(1, "var_b", ty.array<f32, 4>());
+[[stage(vertex)]]
+fn main() -> void {}
+)";
 
-  InitTransform(
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
+
+[[builtin(vertex_idx)]] var<in> _tint_pulling_vertex_index : i32;
+[[binding(0), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+var<private> var_a : f32;
+var<private> var_b : array<f32, 4>;
+
+[[stage(vertex)]]
+fn main() -> void {
+  {
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 16u) + 0u);
+    var_a = bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[(_tint_pulling_pos / 4u)]);
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 16u) + 0u);
+    var_b = vec4<f32>(bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 0u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 4u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 8u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 12u) / 4u)]));
+  }
+}
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
       {{{16,
          InputStepMode::kVertex,
          {{VertexFormat::kF32, 0, 0}, {VertexFormat::kVec4F32, 0, 1}}}}});
+  transform->SetEntryPoint("main");
 
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+  auto got = Transform(src, std::move(transform));
 
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    _tint_pulling_vertex_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __f32
-  }
-  Variable{
-    var_b
-    private
-    __array__f32_4
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
-  {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{16}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__f32]{var_a}
-        Bitcast[__f32]<__f32>{
-          ArrayAccessor[__ptr_storage_buffer__u32]{
-            MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-              Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-              Identifier[not set]{_tint_vertex_data}
-            }
-            Binary[__i32]{
-              Identifier[__ptr_function__i32]{_tint_pulling_pos}
-              divide
-              ScalarConstructor[__u32]{4}
-            }
-          }
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{16}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__array__f32_4]{var_b}
-        TypeConstructor[__vec_4__f32]{
-          __vec_4__f32
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{0}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{4}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{8}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{12}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+  EXPECT_EQ(expect, got);
 }
 
 TEST_F(VertexPullingTest, FloatVectorAttributes) {
-  InitBasicModule();
-  AddVertexInputVariable(0, "var_a", ty.array<f32, 2>());
-  AddVertexInputVariable(1, "var_b", ty.array<f32, 3>());
-  AddVertexInputVariable(2, "var_c", ty.array<f32, 4>());
+  auto* src = R"(
+[[location(0)]] var<in> var_a : array<f32, 2>;
+[[location(1)]] var<in> var_b : array<f32, 3>;
+[[location(2)]] var<in> var_c : array<f32, 4>;
 
-  InitTransform(
+[[stage(vertex)]]
+fn main() -> void {}
+)";
+
+  auto* expect = R"(
+[[block]]
+struct TintVertexData {
+  [[offset(0)]]
+  _tint_vertex_data : [[stride(4)]] array<u32>;
+};
+
+[[builtin(vertex_idx)]] var<in> _tint_pulling_vertex_index : i32;
+[[binding(0), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_0 : TintVertexData;
+[[binding(1), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_1 : TintVertexData;
+[[binding(2), set(4)]] var<storage_buffer> _tint_pulling_vertex_buffer_2 : TintVertexData;
+var<private> var_a : array<f32, 2>;
+var<private> var_b : array<f32, 3>;
+var<private> var_c : array<f32, 4>;
+
+[[stage(vertex)]]
+fn main() -> void {
+  {
+    var _tint_pulling_pos : i32;
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 8u) + 0u);
+    var_a = vec2<f32>(bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 0u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_0._tint_vertex_data[((_tint_pulling_pos + 4u) / 4u)]));
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 12u) + 0u);
+    var_b = vec3<f32>(bitcast<f32>(_tint_pulling_vertex_buffer_1._tint_vertex_data[((_tint_pulling_pos + 0u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_1._tint_vertex_data[((_tint_pulling_pos + 4u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_1._tint_vertex_data[((_tint_pulling_pos + 8u) / 4u)]));
+    _tint_pulling_pos = ((_tint_pulling_vertex_index * 16u) + 0u);
+    var_c = vec4<f32>(bitcast<f32>(_tint_pulling_vertex_buffer_2._tint_vertex_data[((_tint_pulling_pos + 0u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_2._tint_vertex_data[((_tint_pulling_pos + 4u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_2._tint_vertex_data[((_tint_pulling_pos + 8u) / 4u)]), bitcast<f32>(_tint_pulling_vertex_buffer_2._tint_vertex_data[((_tint_pulling_pos + 12u) / 4u)]));
+  }
+}
+)";
+
+  auto transform = std::make_unique<VertexPulling>();
+  transform->SetVertexState(
       {{{8, InputStepMode::kVertex, {{VertexFormat::kVec2F32, 0, 0}}},
         {12, InputStepMode::kVertex, {{VertexFormat::kVec3F32, 0, 1}}},
         {16, InputStepMode::kVertex, {{VertexFormat::kVec4F32, 0, 2}}}}});
+  transform->SetEntryPoint("main");
 
-  auto result = manager()->Run(mod);
-  ASSERT_FALSE(result.diagnostics.contains_errors())
-      << diag::Formatter().format(result.diagnostics);
+  auto got = Transform(src, std::move(transform));
 
-  EXPECT_EQ(R"(Module{
-  TintVertexData Struct{
-    [[block]]
-    StructMember{[[ offset 0 ]] _tint_vertex_data: __array__u32_stride_4}
-  }
-  Variable{
-    Decorations{
-      BuiltinDecoration{vertex_idx}
-    }
-    _tint_pulling_vertex_index
-    in
-    __i32
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{0}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_0
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{1}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_1
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    Decorations{
-      BindingDecoration{2}
-      SetDecoration{4}
-    }
-    _tint_pulling_vertex_buffer_2
-    storage_buffer
-    __struct_TintVertexData
-  }
-  Variable{
-    var_a
-    private
-    __array__f32_2
-  }
-  Variable{
-    var_b
-    private
-    __array__f32_3
-  }
-  Variable{
-    var_c
-    private
-    __array__f32_4
-  }
-  Function main -> __void
-  StageDecoration{vertex}
-  ()
-  {
-    Block{
-      VariableDeclStatement{
-        Variable{
-          _tint_pulling_pos
-          function
-          __i32
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{8}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__array__f32_2]{var_a}
-        TypeConstructor[__vec_2__f32]{
-          __vec_2__f32
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{0}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_0}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{4}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{12}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__array__f32_3]{var_b}
-        TypeConstructor[__vec_3__f32]{
-          __vec_3__f32
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_1}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{0}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_1}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{4}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_1}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{8}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-        }
-      }
-      Assignment{
-        Identifier[__ptr_function__i32]{_tint_pulling_pos}
-        Binary[__i32]{
-          Binary[__i32]{
-            Identifier[__ptr_in__i32]{_tint_pulling_vertex_index}
-            multiply
-            ScalarConstructor[__u32]{16}
-          }
-          add
-          ScalarConstructor[__u32]{0}
-        }
-      }
-      Assignment{
-        Identifier[__ptr_private__array__f32_4]{var_c}
-        TypeConstructor[__vec_4__f32]{
-          __vec_4__f32
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_2}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{0}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_2}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{4}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_2}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{8}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-          Bitcast[__f32]<__f32>{
-            ArrayAccessor[__ptr_storage_buffer__u32]{
-              MemberAccessor[__ptr_storage_buffer__array__u32_stride_4]{
-                Identifier[__ptr_storage_buffer__struct_TintVertexData]{_tint_pulling_vertex_buffer_2}
-                Identifier[not set]{_tint_vertex_data}
-              }
-              Binary[__i32]{
-                Binary[__i32]{
-                  Identifier[__ptr_function__i32]{_tint_pulling_pos}
-                  add
-                  ScalarConstructor[__u32]{12}
-                }
-                divide
-                ScalarConstructor[__u32]{4}
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-)",
-            Demangler().Demangle(result.module, result.module.to_str()));
+  EXPECT_EQ(expect, got);
 }
 
 }  // namespace