From 0f37afb74ef88c05222e660701a3214dd8998994 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Thu, 3 Dec 2020 20:25:29 +0000
Subject: [PATCH] Refactor transformer tests

Transformers will be moving to a transform-on-copy model, instead of transform-in-place.
Rework the tests to handle this.

Bug: tint:390
Change-Id: Id53a0ba0bd365472940d116bd686e450a29e5028
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34571
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
---
 .../bound_array_accessors_transform_test.cc   | 980 ++++++++----------
 .../emit_vertex_point_size_transform_test.cc  | 162 +--
 2 files changed, 545 insertions(+), 597 deletions(-)

diff --git a/src/transform/bound_array_accessors_transform_test.cc b/src/transform/bound_array_accessors_transform_test.cc
index e48308235b..2053277e9a 100644
--- a/src/transform/bound_array_accessors_transform_test.cc
+++ b/src/transform/bound_array_accessors_transform_test.cc
@@ -21,6 +21,7 @@
 #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"
@@ -40,6 +41,7 @@
 #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"
 
@@ -47,47 +49,61 @@ namespace tint {
 namespace transform {
 namespace {
 
+template <typename T = ast::Expression>
+T* FindVariable(ast::Module* mod, std::string name) {
+  if (auto* func = mod->FindFunctionByName("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:
-  BoundArrayAccessorsTest() : td_(&mod_) {
-    auto transform = std::make_unique<BoundArrayAccessorsTransform>(&mod_);
-    transform_ = transform.get();
-    manager_.append(std::move(transform));
+  ast::Module Transform(ast::Module mod) {
+    TypeDeterminer td(&mod);
+    if (!td.Determine()) {
+      error = "Type determination failed: " + td.error();
+      return {};
+    }
+
+    Manager manager;
+    manager.append(std::make_unique<BoundArrayAccessorsTransform>(&mod));
+    if (!manager.Run(&mod)) {
+      error = "manager().Run() errored:\n" + manager.error();
+      return {};
+    }
+
+    return mod;
   }
 
-  ast::BlockStatement* SetupFunctionAndBody() {
-    auto* block = create<ast::BlockStatement>();
-    body_ = block;
-    auto* func =
-        create<ast::Function>("func", ast::VariableList{}, &void_type_, block);
-    mod_.AddFunction(func);
-    return body_;
+  std::string error;
+};
+
+struct ModuleBuilder : public ast::BuilderWithModule {
+  ModuleBuilder() : body_(create<ast::BlockStatement>()) {
+    mod->AddFunction(
+        create<ast::Function>("func", ast::VariableList{}, ty.void_, body_));
   }
 
-  void DeclareVariable(ast::Variable* var) {
+  ast::Module Module() {
+    Build();
+    return std::move(*mod);
+  }
+
+ protected:
+  virtual void Build() = 0;
+  void OnVariableBuilt(ast::Variable* var) override {
     ASSERT_NE(body_, nullptr);
     body_->append(create<ast::VariableDeclStatement>(var));
   }
-
-  TypeDeterminer* td() { return &td_; }
-
-  bool Run() { return manager_.Run(&mod_); }
-
-  /// Creates a new `ast::Node` owned by the Module. When the Module is
-  /// destructed, the `ast::Node` will also be destructed.
-  /// @param args the arguments to pass to the type constructor
-  /// @returns the node pointer
-  template <typename T, typename... ARGS>
-  T* create(ARGS&&... args) {
-    return mod_.create<T>(std::forward<ARGS>(args)...);
-  }
-
- private:
-  ast::Module mod_;
-  TypeDeterminer td_;
-  ast::type::Void void_type_;
-  Manager manager_;
-  BoundArrayAccessorsTransform* transform_;
   ast::BlockStatement* body_ = nullptr;
 };
 
@@ -97,38 +113,25 @@ TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
   // 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))
+          ->set_constructor(Index("a", "c"));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Array ary(&f32, 3);
-  ast::type::Pointer ptr_type(&f32, ast::StorageClass::kFunction);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* c_var = create<ast::Variable>("c", ast::StorageClass::kFunction, &u32);
-  c_var->set_is_const(true);
-  DeclareVariable(c_var);
+  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
 
-  auto* access_idx = create<ast::IdentifierExpression>("c");
-
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"), access_idx);
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &ptr_type);
-  b->set_constructor(accessor);
-  b->set_is_const(true);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
-
-  auto* idx = ptr->idx_expr()->As<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");
 
@@ -139,7 +142,8 @@ TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
   auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], access_idx);
+  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>());
@@ -147,8 +151,8 @@ TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
@@ -158,40 +162,26 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
   // 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)
+          ->set_constructor(Index("a", Index("b", "i")));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Array ary3(&f32, 3);
-  ast::type::Array ary5(&f32, 5);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary3));
-  DeclareVariable(
-      create<ast::Variable>("b", ast::StorageClass::kFunction, &ary5));
-  DeclareVariable(
-      create<ast::Variable>("i", ast::StorageClass::kFunction, &u32));
+  auto* c = FindVariable<ast::ArrayAccessorExpression>(&module, "c");
+  ASSERT_NE(c, nullptr);
 
-  auto* b_access_idx = create<ast::IdentifierExpression>("i");
+  ASSERT_TRUE(c->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(c->idx_expr()->Is<ast::CallExpression>());
 
-  auto* a_access_idx = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("b"), b_access_idx);
-
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"), a_access_idx);
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("c", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
-
-  auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+  auto* idx = c->idx_expr()->As<ast::CallExpression>();
   ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
   EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
 
@@ -220,7 +210,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
   tc = sub_idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], b_access_idx);
+  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>());
@@ -234,8 +225,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->idx_expr()->result_type()->Is<ast::type::U32>());
+  ASSERT_NE(c->idx_expr()->result_type(), nullptr);
+  ASSERT_TRUE(c->idx_expr()->result_type()->Is<ast::type::U32>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Scalar) {
@@ -243,38 +234,30 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Scalar) {
   // 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)
+          ->set_constructor(Index("a", 1u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Array ary(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 1u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* 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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
@@ -283,40 +266,25 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
   // 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)
+          ->set_constructor(Index("a", Add("c", Sub(2u, 3u))));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Array ary(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary));
-  DeclareVariable(
-      create<ast::Variable>("c", ast::StorageClass::kFunction, &u32));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* access_idx = create<ast::BinaryExpression>(
-      ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("c"),
-      create<ast::BinaryExpression>(ast::BinaryOp::kSubtract,
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 2)),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 3))));
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"), access_idx);
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
-
-  auto* idx = ptr->idx_expr()->As<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");
 
@@ -327,7 +295,28 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
   auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], access_idx);
+  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>());
@@ -335,8 +324,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_Negative) {
@@ -344,38 +333,30 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Negative) {
   // 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)
+          ->set_constructor(Index("a", -1));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::I32 i32;
-  ast::type::Array ary(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::SintLiteral>(&i32, -1)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* 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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->idx_expr()->result_type()->Is<ast::type::I32>());
+  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
+  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Array_Idx_OutOfBounds) {
@@ -383,38 +364,30 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_OutOfBounds) {
   // 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)
+          ->set_constructor(Index("a", 3u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Array ary(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &ary));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 3u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Scalar) {
@@ -422,38 +395,30 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Scalar) {
   // 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)
+          ->set_constructor(Index("a", 1u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Vector vec(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &vec));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 1u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* 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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
@@ -462,40 +427,25 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
   // 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)
+          ->set_constructor(Index("a", Add("c", Sub(2u, 3u))));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Vector vec(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &vec));
-  DeclareVariable(
-      create<ast::Variable>("c", ast::StorageClass::kFunction, &u32));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* access_idx = create<ast::BinaryExpression>(
-      ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("c"),
-      create<ast::BinaryExpression>(ast::BinaryOp::kSubtract,
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 2)),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 3))));
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::CallExpression>());
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"), access_idx);
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
-
-  auto* idx = ptr->idx_expr()->As<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");
 
@@ -505,7 +455,27 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
   auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], access_idx);
+  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>());
@@ -513,8 +483,8 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_Negative) {
@@ -522,38 +492,30 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Negative) {
   // 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)
+          ->set_constructor(Index("a", -1));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::I32 i32;
-  ast::type::Vector vec(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &vec));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::SintLiteral>(&i32, -1)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* 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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->idx_expr()->result_type()->Is<ast::type::I32>());
+  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
+  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Vector_Idx_OutOfBounds) {
@@ -561,38 +523,30 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_OutOfBounds) {
   // 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)
+          ->set_constructor(Index("a", 3u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Vector vec(&f32, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &vec));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("a"),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 3u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
-
-  auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
+  auto* scalar = b->idx_expr()->As<ast::ScalarConstructorExpression>();
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 2u);
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) {
@@ -600,35 +554,24 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) {
   // 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)
+          ->set_constructor(Index(Index("a", 2u), 1u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::UintLiteral>(&u32, 2u))),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 1u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
 
@@ -639,15 +582,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
@@ -656,43 +599,25 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
   // 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)
+          ->set_constructor(Index(Index("a", Add("c", Sub(2u, 3u))), 1u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
-  DeclareVariable(
-      create<ast::Variable>("c", ast::StorageClass::kFunction, &u32));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* access_idx = create<ast::BinaryExpression>(
-      ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("c"),
-      create<ast::BinaryExpression>(ast::BinaryOp::kSubtract,
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 2)),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 3))));
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"), access_idx),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 1u)));
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  ASSERT_TRUE(b->array()->Is<ast::ArrayAccessorExpression>());
+  auto* ary = b->array()->As<ast::ArrayAccessorExpression>();
 
   ASSERT_TRUE(ary->idx_expr()->Is<ast::CallExpression>());
   auto* idx = ary->idx_expr()->As<ast::CallExpression>();
@@ -706,7 +631,27 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
   auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], access_idx);
+  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>());
@@ -717,15 +662,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
@@ -734,44 +679,25 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
   // 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)
+          ->set_constructor(Index(Index("a", 1u), Add("c", Sub(2u, 3u))));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
-  DeclareVariable(
-      create<ast::Variable>("c", ast::StorageClass::kFunction, &u32));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* access_idx = create<ast::BinaryExpression>(
-      ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("c"),
-      create<ast::BinaryExpression>(ast::BinaryOp::kSubtract,
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 2)),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 3))));
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::UintLiteral>(&u32, 1u))),
-      access_idx);
-  auto* ptr = accessor;
-
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
@@ -780,8 +706,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
   ASSERT_TRUE(scalar->literal()->Is<ast::UintLiteral>());
   EXPECT_EQ(scalar->literal()->As<ast::UintLiteral>()->value(), 1u);
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
-  auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+  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");
 
@@ -792,7 +718,27 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
   auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
   EXPECT_TRUE(tc->type()->Is<ast::type::U32>());
   ASSERT_EQ(tc->values().size(), 1u);
-  ASSERT_EQ(tc->values()[0], access_idx);
+  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>());
@@ -803,8 +749,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
 
-  ASSERT_NE(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) {
@@ -812,34 +758,24 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) {
   // var b : f32 = a[-1][1]
   //
   // -> var b : f32 = a[0][1]
-  ast::type::F32 f32;
-  ast::type::I32 i32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  struct Builder : ModuleBuilder {
+    void Build() override {
+      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
+      Var("b", ast::StorageClass::kFunction, ty.f32)
+          ->set_constructor(Index(Index("a", -1), 1));
+    }
+  };
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::SintLiteral>(&i32, -1))),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::SintLiteral>(&i32, 1)));
-  auto* ptr = accessor;
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
 
@@ -850,15 +786,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->idx_expr()->result_type()->Is<ast::type::I32>());
+  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
+  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) {
@@ -866,34 +802,24 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) {
   // var b : f32 = a[2][-1]
   //
   // -> var b : f32 = a[2][0]
-  ast::type::F32 f32;
-  ast::type::I32 i32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  struct Builder : ModuleBuilder {
+    void Build() override {
+      Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
+      Var("b", ast::StorageClass::kFunction, ty.f32)
+          ->set_constructor(Index(Index("a", 2), -1));
+    }
+  };
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::SintLiteral>(&i32, 2))),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::SintLiteral>(&i32, -1)));
-  auto* ptr = accessor;
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
 
@@ -904,15 +830,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->idx_expr()->result_type()->Is<ast::type::I32>());
+  ASSERT_NE(b->idx_expr()->result_type(), nullptr);
+  ASSERT_TRUE(b->idx_expr()->result_type()->Is<ast::type::I32>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) {
@@ -920,35 +846,24 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) {
   // 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)
+          ->set_constructor(Index(Index("a", 5u), 1u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::UintLiteral>(&u32, 5u))),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 1u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
 
@@ -959,15 +874,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) {
@@ -975,35 +890,24 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) {
   // 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)
+          ->set_constructor(Index(Index("a", 2u), 5u));
+    }
+  };
 
-  ast::type::F32 f32;
-  ast::type::U32 u32;
-  ast::type::Matrix mat(&f32, 2, 3);
+  ast::Module module = Transform(Builder{}.Module());
+  ASSERT_EQ(error, "");
 
-  SetupFunctionAndBody();
-  DeclareVariable(
-      create<ast::Variable>("a", ast::StorageClass::kFunction, &mat));
+  auto* b = FindVariable<ast::ArrayAccessorExpression>(&module, "b");
+  ASSERT_NE(b, nullptr);
 
-  auto* accessor = create<ast::ArrayAccessorExpression>(
-      create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("a"),
-          create<ast::ScalarConstructorExpression>(
-              create<ast::UintLiteral>(&u32, 2u))),
-      create<ast::ScalarConstructorExpression>(
-          create<ast::UintLiteral>(&u32, 5u)));
-  auto* ptr = accessor;
+  ASSERT_TRUE(b->Is<ast::ArrayAccessorExpression>());
 
-  auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
-  b->set_constructor(accessor);
-  DeclareVariable(b);
-
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ASSERT_TRUE(Run());
-  ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
-
-  ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
-  auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+  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>());
 
@@ -1014,15 +918,15 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) {
   ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
   ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32>());
 
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
-  ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ConstructorExpression>());
+  ASSERT_TRUE(b->idx_expr()->Is<ast::ScalarConstructorExpression>());
 
-  scalar = ptr->idx_expr()->As<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(ptr->idx_expr()->result_type(), nullptr);
-  ASSERT_TRUE(ptr->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>());
 }
 
 // TODO(dsinclair): Implement when constant_id exists
diff --git a/src/transform/emit_vertex_point_size_transform_test.cc b/src/transform/emit_vertex_point_size_transform_test.cc
index 0167bf61bf..58337e5e63 100644
--- a/src/transform/emit_vertex_point_size_transform_test.cc
+++ b/src/transform/emit_vertex_point_size_transform_test.cc
@@ -19,49 +19,79 @@
 
 #include "gtest/gtest.h"
 #include "src/ast/builder.h"
-#include "src/ast/call_statement.h"
 #include "src/ast/stage_decoration.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/diagnostic/diagnostic.h"
+#include "src/diagnostic/formatter.h"
 #include "src/transform/manager.h"
 
 namespace tint {
 namespace transform {
 namespace {
 
-class EmitVertexPointSizeTransformTest : public testing::Test,
-                                         public ast::BuilderWithModule {
+class EmitVertexPointSizeTransformTest : public testing::Test {
  public:
-  EmitVertexPointSizeTransformTest() {
-    auto transform = std::make_unique<EmitVertexPointSizeTransform>(mod);
-    manager = std::make_unique<Manager>();
-    manager->append(std::move(transform));
+  struct Output {
+    ast::Module module;
+    diag::List diagnostics;
+  };
+  Output Transform(ast::Module mod) {
+    Manager manager;
+    manager.append(std::make_unique<EmitVertexPointSizeTransform>(&mod));
+    manager.Run(&mod);
+    Output out;
+    out.module = std::move(mod);
+    auto err = manager.error();
+    if (!err.empty()) {
+      diag::Diagnostic diag;
+      diag.message = err;
+      diag.severity = diag::Severity::Error;
+      out.diagnostics.add(std::move(diag));
+    }
+    return out;
+  }
+};
+
+struct ModuleBuilder : public ast::BuilderWithModule {
+  ModuleBuilder() {}
+
+  ast::Module Module() {
+    Build();
+    return std::move(*mod);
   }
 
-  std::unique_ptr<Manager> manager;
+ protected:
+  virtual void Build() = 0;
 };
 
 TEST_F(EmitVertexPointSizeTransformTest, VertexStageBasic) {
-  auto* block = create<ast::BlockStatement>(Source{});
-  block->append(create<ast::CallStatement>(create<ast::CallExpression>(
-      Source{},
-      create<ast::IdentifierExpression>(
-          Source{}, "builtin_assignments_should_happen_before_this"),
-      ast::ExpressionList{})));
+  struct Builder : ModuleBuilder {
+    void Build() override {
+      auto* block = create<ast::BlockStatement>(Source{});
 
-  mod->AddFunction(create<ast::Function>(
-      "non_entry_a", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{})));
+      block->append(create<ast::VariableDeclStatement>(
+          Var("builtin_assignments_should_happen_before_this",
+              tint::ast::StorageClass::kFunction, ty.f32)));
 
-  auto* entry = create<ast::Function>("entry", ast::VariableList{},
-                                      create<ast::type::Void>(), block);
-  entry->set_decorations(
-      {create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{})});
-  mod->AddFunction(entry);
+      mod->AddFunction(
+          create<ast::Function>("non_entry_a", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{})));
 
-  mod->AddFunction(create<ast::Function>(
-      "non_entry_b", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{})));
+      auto* entry =
+          create<ast::Function>("entry", ast::VariableList{}, ty.void_, block);
+      entry->set_decorations({create<ast::StageDecoration>(
+          ast::PipelineStage::kVertex, Source{})});
+      mod->AddFunction(entry);
 
-  manager->Run(mod);
+      mod->AddFunction(
+          create<ast::Function>("non_entry_b", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{})));
+    }
+  };
+
+  auto result = Transform(Builder{}.Module());
+  ASSERT_FALSE(result.diagnostics.contains_errors())
+      << diag::Formatter().format(result.diagnostics);
 
   auto* expected = R"(Module{
   DecoratedVariable{
@@ -84,10 +114,12 @@ TEST_F(EmitVertexPointSizeTransformTest, VertexStageBasic) {
       Identifier[__ptr_out__f32]{tint_pointsize}
       ScalarConstructor[__f32]{1.000000}
     }
-    Call[not set]{
-      Identifier[not set]{builtin_assignments_should_happen_before_this}
-      (
-      )
+    VariableDeclStatement{
+      Variable{
+        builtin_assignments_should_happen_before_this
+        function
+        __f32
+      }
     }
   }
   Function non_entry_b -> __void
@@ -96,26 +128,32 @@ TEST_F(EmitVertexPointSizeTransformTest, VertexStageBasic) {
   }
 }
 )";
-  EXPECT_EQ(expected, mod->to_str());
+  EXPECT_EQ(expected, result.module.to_str());
 }
 
 TEST_F(EmitVertexPointSizeTransformTest, VertexStageEmpty) {
-  mod->AddFunction(create<ast::Function>(
-      "non_entry_a", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{})));
+  struct Builder : ModuleBuilder {
+    void Build() override {
+      mod->AddFunction(
+          create<ast::Function>("non_entry_a", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{})));
 
-  auto* entry = create<ast::Function>("entry", ast::VariableList{},
-                                      create<ast::type::Void>(),
-                                      create<ast::BlockStatement>(Source{}));
-  entry->set_decorations(
-      {create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{})});
-  mod->AddFunction(entry);
+      auto* entry =
+          create<ast::Function>("entry", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{}));
+      entry->set_decorations({create<ast::StageDecoration>(
+          ast::PipelineStage::kVertex, Source{})});
+      mod->AddFunction(entry);
 
-  mod->AddFunction(create<ast::Function>(
-      "non_entry_b", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{})));
+      mod->AddFunction(
+          create<ast::Function>("non_entry_b", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{})));
+    }
+  };
 
-  manager->Run(mod);
+  auto result = Transform(Builder{}.Module());
+  ASSERT_FALSE(result.diagnostics.contains_errors())
+      << diag::Formatter().format(result.diagnostics);
 
   auto* expected = R"(Module{
   DecoratedVariable{
@@ -145,25 +183,31 @@ TEST_F(EmitVertexPointSizeTransformTest, VertexStageEmpty) {
   }
 }
 )";
-  EXPECT_EQ(expected, mod->to_str());
+  EXPECT_EQ(expected, result.module.to_str());
 }
 
 TEST_F(EmitVertexPointSizeTransformTest, NonVertexStage) {
-  auto* fragment_entry = create<ast::Function>(
-      "fragment_entry", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{}));
-  fragment_entry->set_decorations(
-      {create<ast::StageDecoration>(ast::PipelineStage::kFragment, Source{})});
-  mod->AddFunction(fragment_entry);
+  struct Builder : ModuleBuilder {
+    void Build() override {
+      auto* fragment_entry =
+          create<ast::Function>("fragment_entry", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{}));
+      fragment_entry->set_decorations({create<ast::StageDecoration>(
+          ast::PipelineStage::kFragment, Source{})});
+      mod->AddFunction(fragment_entry);
 
-  auto* compute_entry = create<ast::Function>(
-      "compute_entry", ast::VariableList{}, create<ast::type::Void>(),
-      create<ast::BlockStatement>(Source{}));
-  compute_entry->set_decorations(
-      {create<ast::StageDecoration>(ast::PipelineStage::kCompute, Source{})});
-  mod->AddFunction(compute_entry);
+      auto* compute_entry =
+          create<ast::Function>("compute_entry", ast::VariableList{}, ty.void_,
+                                create<ast::BlockStatement>(Source{}));
+      compute_entry->set_decorations({create<ast::StageDecoration>(
+          ast::PipelineStage::kCompute, Source{})});
+      mod->AddFunction(compute_entry);
+    }
+  };
 
-  manager->Run(mod);
+  auto result = Transform(Builder{}.Module());
+  ASSERT_FALSE(result.diagnostics.contains_errors())
+      << diag::Formatter().format(result.diagnostics);
 
   auto* expected = R"(Module{
   Function fragment_entry -> __void
@@ -178,7 +222,7 @@ TEST_F(EmitVertexPointSizeTransformTest, NonVertexStage) {
   }
 }
 )";
-  EXPECT_EQ(expected, mod->to_str());
+  EXPECT_EQ(expected, result.module.to_str());
 }
 
 }  // namespace