diff --git a/BUILD.gn b/BUILD.gn
index ebf5362..60f3b85 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -904,6 +904,7 @@
     "src/writer/spirv/operand_test.cc",
     "src/writer/spirv/spv_dump.cc",
     "src/writer/spirv/spv_dump.h",
+    "src/writer/spirv/test_helper.h",
   ]
 
   configs += [
@@ -1049,6 +1050,7 @@
     "src/writer/wgsl/generator_impl_unary_op_test.cc",
     "src/writer/wgsl/generator_impl_variable_decl_statement_test.cc",
     "src/writer/wgsl/generator_impl_variable_test.cc",
+    "src/writer/wgsl/test_helper.h",
   ]
 
   configs += [
@@ -1101,6 +1103,7 @@
     "src/writer/msl/generator_impl_unary_op_test.cc",
     "src/writer/msl/generator_impl_variable_decl_statement_test.cc",
     "src/writer/msl/namer_test.cc",
+    "src/writer/msl/test_helper.h",
   ]
 
   configs += [
diff --git a/include/tint/tint.h b/include/tint/tint.h
index a0ec913..e09537c 100644
--- a/include/tint/tint.h
+++ b/include/tint/tint.h
@@ -22,6 +22,7 @@
 #include "src/context.h"
 #include "src/diagnostic/printer.h"
 #include "src/inspector/inspector.h"
+#include "src/namer.h"
 #include "src/reader/reader.h"
 #include "src/transform/bound_array_accessors_transform.h"
 #include "src/transform/manager.h"
diff --git a/samples/main.cc b/samples/main.cc
index 53d490a..c6db485 100644
--- a/samples/main.cc
+++ b/samples/main.cc
@@ -418,7 +418,7 @@
     options.format = Format::kSpvAsm;
   }
 
-  tint::Context ctx;
+  tint::Context ctx(std::make_unique<tint::NoopNamer>());
 
   std::unique_ptr<tint::reader::Reader> reader;
   std::unique_ptr<tint::Source::File> source_file;
@@ -532,25 +532,29 @@
 
 #if TINT_BUILD_SPV_WRITER
   if (options.format == Format::kSpirv || options.format == Format::kSpvAsm) {
-    writer = std::make_unique<tint::writer::spirv::Generator>(std::move(mod));
+    writer =
+        std::make_unique<tint::writer::spirv::Generator>(&ctx, std::move(mod));
   }
 #endif  // TINT_BUILD_SPV_WRITER
 
 #if TINT_BUILD_WGSL_WRITER
   if (options.format == Format::kWgsl) {
-    writer = std::make_unique<tint::writer::wgsl::Generator>(std::move(mod));
+    writer =
+        std::make_unique<tint::writer::wgsl::Generator>(&ctx, std::move(mod));
   }
 #endif  // TINT_BUILD_WGSL_WRITER
 
 #if TINT_BUILD_MSL_WRITER
   if (options.format == Format::kMsl) {
-    writer = std::make_unique<tint::writer::msl::Generator>(std::move(mod));
+    writer =
+        std::make_unique<tint::writer::msl::Generator>(&ctx, std::move(mod));
   }
 #endif  // TINT_BUILD_MSL_WRITER
 
 #if TINT_BUILD_HLSL_WRITER
   if (options.format == Format::kHlsl) {
-    writer = std::make_unique<tint::writer::hlsl::Generator>(std::move(mod));
+    writer =
+        std::make_unique<tint::writer::hlsl::Generator>(&ctx, std::move(mod));
   }
 #endif  // TINT_BUILD_HLSL_WRITER
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 0e579e5..630828d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -568,6 +568,7 @@
     writer/spirv/operand_test.cc
     writer/spirv/spv_dump.cc
     writer/spirv/spv_dump.h
+    writer/spirv/test_helper.h
   )
 endif()
 
@@ -599,6 +600,7 @@
     writer/wgsl/generator_impl_unary_op_test.cc
     writer/wgsl/generator_impl_variable_decl_statement_test.cc
     writer/wgsl/generator_impl_variable_test.cc
+    writer/wgsl/test_helper.h
   )
 endif()
 
@@ -633,6 +635,7 @@
     writer/msl/generator_impl_unary_op_test.cc
     writer/msl/generator_impl_variable_decl_statement_test.cc
     writer/msl/namer_test.cc
+    writer/msl/test_helper.h
   )
 endif()
 
diff --git a/src/context.cc b/src/context.cc
index 4285eb4..97cb16c 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -16,11 +16,14 @@
 
 #include <utility>
 
+#include "src/namer.h"
 #include "src/type_manager.h"
 
 namespace tint {
 
-Context::Context() = default;
+Context::Context() : namer_(std::make_unique<HashingNamer>()) {}
+
+Context::Context(std::unique_ptr<Namer> namer) : namer_(std::move(namer)) {}
 
 Context::~Context() = default;
 
diff --git a/src/context.h b/src/context.h
index f1117f5..40c7a14 100644
--- a/src/context.h
+++ b/src/context.h
@@ -15,6 +15,9 @@
 #ifndef SRC_CONTEXT_H_
 #define SRC_CONTEXT_H_
 
+#include <memory>
+
+#include "src/namer.h"
 #include "src/type_manager.h"
 
 namespace tint {
@@ -23,8 +26,11 @@
 /// the system.
 class Context {
  public:
-  /// Constructs a context with an empty type manager.
+  /// Constructor
   Context();
+  /// Constructor
+  /// @param namer the namer to set into the context
+  explicit Context(std::unique_ptr<Namer> namer);
   /// Destructor
   ~Context();
   /// Resets the state of this context.
@@ -33,8 +39,12 @@
   /// @returns the Type Manager
   TypeManager& type_mgr() { return type_mgr_; }
 
+  /// @returns the namer object
+  Namer* namer() const { return namer_.get(); }
+
  private:
   TypeManager type_mgr_;
+  std::unique_ptr<Namer> namer_;
 };
 
 }  // namespace tint
diff --git a/src/inspector/inspector.cc b/src/inspector/inspector.cc
index 5f4936e..cb9b703 100644
--- a/src/inspector/inspector.cc
+++ b/src/inspector/inspector.cc
@@ -36,14 +36,22 @@
 #include "src/ast/type/type.h"
 #include "src/ast/type/vector_type.h"
 #include "src/ast/uint_literal.h"
-#include "src/namer.h"
 
 namespace tint {
 namespace inspector {
 
-Inspector::Inspector(const ast::Module& module) : module_(module) {}
+Inspector::Inspector(const ast::Module& module)
+    : ctx_(new Context()), context_is_owned_(true), module_(module) {}
 
-Inspector::~Inspector() = default;
+Inspector::Inspector(Context* ctx, const ast::Module& module)
+    : ctx_(ctx), context_is_owned_(false), module_(module) {
+  assert(ctx);
+}
+
+Inspector::~Inspector() {
+  if (context_is_owned_)
+    delete ctx_;
+}
 
 std::vector<EntryPoint> Inspector::GetEntryPoints() {
   std::vector<EntryPoint> result;
@@ -55,7 +63,7 @@
 
     EntryPoint entry_point;
     entry_point.name = func->name();
-    entry_point.remapped_name = namer_.NameFor(func->name());
+    entry_point.remapped_name = ctx_->namer()->NameFor(func->name());
     entry_point.stage = func->pipeline_stage();
     std::tie(entry_point.workgroup_size_x, entry_point.workgroup_size_y,
              entry_point.workgroup_size_z) = func->workgroup_size();
@@ -82,7 +90,7 @@
   //  if (!func) {
   //    return {};
   //  }
-  //  return namer_.NameFor(entry_point);
+  //  return ctx_->namer()->NameFor(entry_point);
   return entry_point;
 }
 
diff --git a/src/inspector/inspector.h b/src/inspector/inspector.h
index 01d0f73..d14c1df 100644
--- a/src/inspector/inspector.h
+++ b/src/inspector/inspector.h
@@ -23,9 +23,9 @@
 
 #include "src/ast/module.h"
 #include "src/ast/pipeline_stage.h"
+#include "src/context.h"
 #include "src/inspector/entry_point.h"
 #include "src/inspector/scalar.h"
-#include "src/namer.h"
 
 namespace tint {
 namespace inspector {
@@ -72,8 +72,13 @@
 class Inspector {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module Shader module to extract information from.
   explicit Inspector(const ast::Module& module);
+  /// Constructor
+  /// @param ctx the context, must be non-null
+  /// @param module Shader module to extract information from.
+  Inspector(Context* ctx, const ast::Module& module);
   ~Inspector();
 
   /// @returns error messages from the Inspector
@@ -128,9 +133,10 @@
       const std::string& entry_point);
 
  private:
+  Context* ctx_ = nullptr;
+  bool context_is_owned_ = false;
   const ast::Module& module_;
   std::string error_;
-  tint::Namer namer_;
 
   /// @param name name of the entry point to find
   /// @returns a pointer to the entry point if it exists, otherwise returns
diff --git a/src/namer.cc b/src/namer.cc
index 3bd5bac..54c17ad 100644
--- a/src/namer.cc
+++ b/src/namer.cc
@@ -24,7 +24,16 @@
 
 Namer::~Namer() = default;
 
-std::string Namer::NameFor(const std::string& name) {
+bool Namer::IsMapped(const std::string& name) {
+  auto it = name_map_.find(name);
+  return it != name_map_.end();
+}
+
+HashingNamer::HashingNamer() = default;
+
+HashingNamer::~HashingNamer() = default;
+
+std::string HashingNamer::NameFor(const std::string& name) {
   auto it = name_map_.find(name);
   if (it != name_map_.end()) {
     return it->second;
@@ -42,9 +51,13 @@
   return ret_name.str();
 }
 
-bool Namer::IsMapped(const std::string& name) {
-  auto it = name_map_.find(name);
-  return it != name_map_.end();
+NoopNamer::NoopNamer() = default;
+
+NoopNamer::~NoopNamer() = default;
+
+std::string NoopNamer::NameFor(const std::string& name) {
+  name_map_[name] = name;
+  return name;
 }
 
 }  // namespace tint
diff --git a/src/namer.h b/src/namer.h
index 69acf00..2bd1a18 100644
--- a/src/namer.h
+++ b/src/namer.h
@@ -21,29 +21,52 @@
 
 namespace tint {
 
-/// Remaps maps names to a hashed version. This keeps the provided user input
-/// from traveling through to the backend compiler.
+/// Base class for the namers.
 class Namer {
  public:
   /// Constructor
   Namer();
-  ~Namer();
+  virtual ~Namer();
 
   /// Returns a sanitized version of |name|
   /// @param name the name to sanitize
   /// @returns the sanitized version of |name|
-  std::string NameFor(const std::string& name);
+  virtual std::string NameFor(const std::string& name) = 0;
 
   /// Returns if the given name has been mapped already
   /// @param name the name to check
   /// @returns true if the name has been mapped
   bool IsMapped(const std::string& name);
 
- private:
+ protected:
   /// Map of original name to new name.
   std::unordered_map<std::string, std::string> name_map_;
 };
 
+/// A namer class which hashes the name
+class HashingNamer : public Namer {
+ public:
+  HashingNamer();
+  ~HashingNamer() override;
+
+  /// Returns a sanitized version of |name|
+  /// @param name the name to sanitize
+  /// @returns the sanitized version of |name|
+  std::string NameFor(const std::string& name) override;
+};
+
+/// A namer which just returns the provided string
+class NoopNamer : public Namer {
+ public:
+  NoopNamer();
+  ~NoopNamer() override;
+
+  /// Returns |name|
+  /// @param name the name
+  /// @returns |name|
+  std::string NameFor(const std::string& name) override;
+};
+
 }  // namespace tint
 
 #endif  // SRC_NAMER_H_
diff --git a/src/namer_test.cc b/src/namer_test.cc
index f6e64f7..bc3bbbd 100644
--- a/src/namer_test.cc
+++ b/src/namer_test.cc
@@ -19,26 +19,47 @@
 namespace tint {
 namespace {
 
-using NamerTest = testing::Test;
+using Namer_HashingNamer_Test = testing::Test;
 
-TEST_F(NamerTest, ReturnsName) {
-  Namer n;
+TEST_F(Namer_HashingNamer_Test, ReturnsName) {
+  HashingNamer n;
   EXPECT_EQ("tint_6d795f6e616d65", n.NameFor("my_name"));
 }
 
-TEST_F(NamerTest, ReturnsSameValueForSameName) {
-  Namer n;
+TEST_F(Namer_HashingNamer_Test, ReturnsSameValueForSameName) {
+  HashingNamer n;
   EXPECT_EQ("tint_6e616d6531", n.NameFor("name1"));
   EXPECT_EQ("tint_6e616d6532", n.NameFor("name2"));
   EXPECT_EQ("tint_6e616d6531", n.NameFor("name1"));
 }
 
-TEST_F(NamerTest, IsMapped) {
-  Namer n;
+TEST_F(Namer_HashingNamer_Test, IsMapped) {
+  HashingNamer n;
   EXPECT_FALSE(n.IsMapped("my_name"));
   EXPECT_EQ("tint_6d795f6e616d65", n.NameFor("my_name"));
   EXPECT_TRUE(n.IsMapped("my_name"));
 }
 
+using Namer_NoopNamer_Test = testing::Test;
+
+TEST_F(Namer_NoopNamer_Test, ReturnsName) {
+  NoopNamer n;
+  EXPECT_EQ("my_name", n.NameFor("my_name"));
+}
+
+TEST_F(Namer_NoopNamer_Test, ReturnsSameValueForSameName) {
+  NoopNamer n;
+  EXPECT_EQ("name1", n.NameFor("name1"));
+  EXPECT_EQ("name2", n.NameFor("name2"));
+  EXPECT_EQ("name1", n.NameFor("name1"));
+}
+
+TEST_F(Namer_NoopNamer_Test, IsMapped) {
+  NoopNamer n;
+  EXPECT_FALSE(n.IsMapped("my_name"));
+  EXPECT_EQ("my_name", n.NameFor("my_name"));
+  EXPECT_TRUE(n.IsMapped("my_name"));
+}
+
 }  // namespace
 }  // namespace tint
diff --git a/src/type_determiner.h b/src/type_determiner.h
index 1384028..af279f5 100644
--- a/src/type_determiner.h
+++ b/src/type_determiner.h
@@ -44,7 +44,7 @@
 class TypeDeterminer {
  public:
   /// Constructor
-  /// @param ctx the tint context
+  /// @param ctx the tint context, must be non-null
   /// @param mod the module to update with typing information
   TypeDeterminer(Context* ctx, ast::Module* mod);
   ~TypeDeterminer();
diff --git a/src/writer/hlsl/generator.cc b/src/writer/hlsl/generator.cc
index d521533..fa76960 100644
--- a/src/writer/hlsl/generator.cc
+++ b/src/writer/hlsl/generator.cc
@@ -22,14 +22,18 @@
 
 Generator::Generator(ast::Module module)
     : Text(std::move(module)),
-      impl_(std::make_unique<GeneratorImpl>(&module_)) {}
+      impl_(std::make_unique<GeneratorImpl>(ctx_, &module_)) {}
+
+Generator::Generator(Context* ctx, ast::Module module)
+    : Text(ctx, std::move(module)),
+      impl_(std::make_unique<GeneratorImpl>(ctx_, &module_)) {}
 
 Generator::~Generator() = default;
 
 void Generator::Reset() {
   set_error("");
   out_ = std::ostringstream();
-  impl_ = std::make_unique<GeneratorImpl>(&module_);
+  impl_ = std::make_unique<GeneratorImpl>(ctx_, &module_);
 }
 
 bool Generator::Generate() {
diff --git a/src/writer/hlsl/generator.h b/src/writer/hlsl/generator.h
index 83f6d27..93213e6 100644
--- a/src/writer/hlsl/generator.h
+++ b/src/writer/hlsl/generator.h
@@ -30,8 +30,13 @@
 class Generator : public Text {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module the module to convert
   explicit Generator(ast::Module module);
+  /// Constructor
+  /// @param ctx the context, must be non-null
+  /// @param module the module to convert
+  Generator(Context* ctx, ast::Module module);
   ~Generator() override;
 
   /// Resets the generator
diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index 1ae094c..726757b 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -104,7 +104,10 @@
 
 }  // namespace
 
-GeneratorImpl::GeneratorImpl(ast::Module* module) : module_(module) {}
+GeneratorImpl::GeneratorImpl(Context* ctx, ast::Module* module)
+    : ctx_(ctx), module_(module) {
+  assert(ctx);
+}
 
 GeneratorImpl::~GeneratorImpl() = default;
 
diff --git a/src/writer/hlsl/generator_impl.h b/src/writer/hlsl/generator_impl.h
index 1bb9a32..c51fcf2 100644
--- a/src/writer/hlsl/generator_impl.h
+++ b/src/writer/hlsl/generator_impl.h
@@ -25,6 +25,7 @@
 #include "src/ast/scalar_constructor_expression.h"
 #include "src/ast/type/struct_type.h"
 #include "src/ast/type_constructor_expression.h"
+#include "src/context.h"
 #include "src/scope_stack.h"
 #include "src/writer/hlsl/namer.h"
 
@@ -36,8 +37,9 @@
 class GeneratorImpl {
  public:
   /// Constructor
+  /// @param ctx the context object, must be non-null
   /// @param module the module to generate
-  explicit GeneratorImpl(ast::Module* module);
+  GeneratorImpl(Context* ctx, ast::Module* module);
   ~GeneratorImpl();
 
   /// Increment the emitter indent level
@@ -371,6 +373,7 @@
   size_t indent_ = 0;
 
   Namer namer_;
+  Context* ctx_ = nullptr;
   ast::Module* module_ = nullptr;
   std::string current_ep_name_;
   bool generating_entry_point_ = false;
diff --git a/src/writer/hlsl/generator_impl_alias_type_test.cc b/src/writer/hlsl/generator_impl_alias_type_test.cc
index d50db38..ae8a6e6 100644
--- a/src/writer/hlsl/generator_impl_alias_type_test.cc
+++ b/src/writer/hlsl/generator_impl_alias_type_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/ast/module.h"
 #include "src/ast/struct.h"
 #include "src/ast/struct_member.h"
 #include "src/ast/struct_member_decoration.h"
@@ -33,7 +32,7 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias("a", &f32);
 
-  ASSERT_TRUE(gen().EmitConstructedType(out(), &alias)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructedType(out, &alias)) << gen.error();
   EXPECT_EQ(result(), R"(typedef float a;
 )");
 }
@@ -42,7 +41,7 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias("float", &f32);
 
-  ASSERT_TRUE(gen().EmitConstructedType(out(), &alias)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructedType(out, &alias)) << gen.error();
   EXPECT_EQ(result(), R"(typedef float float_tint_0;
 )");
 }
@@ -67,9 +66,7 @@
   ast::type::StructType s("A", std::move(str));
   ast::type::AliasType alias("B", &s);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(gen().EmitConstructedType(out(), &alias)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructedType(out, &alias)) << gen.error();
   EXPECT_EQ(result(), R"(struct B {
   float a;
   int b;
diff --git a/src/writer/hlsl/generator_impl_array_accessor_test.cc b/src/writer/hlsl/generator_impl_array_accessor_test.cc
index 5b488d4..b399f7e 100644
--- a/src/writer/hlsl/generator_impl_array_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_array_accessor_test.cc
@@ -37,7 +37,7 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "ary[5]");
 }
 
@@ -47,7 +47,7 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "ary[idx]");
 }
 
diff --git a/src/writer/hlsl/generator_impl_assign_test.cc b/src/writer/hlsl/generator_impl_assign_test.cc
index c366717..8b9da6a 100644
--- a/src/writer/hlsl/generator_impl_assign_test.cc
+++ b/src/writer/hlsl/generator_impl_assign_test.cc
@@ -32,9 +32,9 @@
   auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(), "  lhs = rhs;\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_binary_test.cc b/src/writer/hlsl/generator_impl_binary_test.cc
index bec7a6d..fe5b0ad 100644
--- a/src/writer/hlsl/generator_impl_binary_test.cc
+++ b/src/writer/hlsl/generator_impl_binary_test.cc
@@ -50,7 +50,7 @@
   return out;
 }
 
-using HlslBinaryTest = TestHelperBase<testing::TestWithParam<BinaryData>>;
+using HlslBinaryTest = TestParamHelper<BinaryData>;
 TEST_P(HlslBinaryTest, Emit) {
   auto params = GetParam();
 
@@ -59,7 +59,7 @@
 
   ast::BinaryExpression expr(params.op, std::move(left), std::move(right));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -90,7 +90,7 @@
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, std::move(left),
                              std::move(right));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp)");
   EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
 if (_tint_tmp) {
@@ -113,7 +113,7 @@
       std::make_unique<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
                                               std::move(c), std::move(d)));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp_0)");
   EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
 if (_tint_tmp) {
@@ -137,7 +137,7 @@
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, std::move(left),
                              std::move(right));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp)");
   EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
 if (!_tint_tmp) {
@@ -190,7 +190,7 @@
                         std::move(body));
   expr.set_else_statements(std::move(else_stmts));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = a;
 if (_tint_tmp) {
   _tint_tmp = b;
@@ -223,7 +223,7 @@
                                               std::move(a), std::move(b)),
       std::move(c)));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = a;
 if (_tint_tmp) {
   _tint_tmp = b;
@@ -251,7 +251,7 @@
                                                   std::move(b), std::move(c)),
           std::move(d)));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = b;
 if (!_tint_tmp) {
   _tint_tmp = c;
@@ -282,7 +282,7 @@
 
   ast::VariableDeclStatement expr(std::move(var));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = b;
 if (_tint_tmp) {
   _tint_tmp = c;
@@ -309,7 +309,7 @@
                 std::make_unique<ast::BinaryExpression>(
                     ast::BinaryOp::kLogicalOr, std::move(b), std::move(c))));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
 if (_tint_tmp) {
   bool _tint_tmp_0 = b;
@@ -329,7 +329,7 @@
 
   auto func =
       std::make_unique<ast::Function>("foo", ast::VariableList{}, &void_type);
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::BinaryExpression>(
@@ -354,7 +354,7 @@
   ast::CallStatement expr(std::make_unique<ast::CallExpression>(
       std::make_unique<ast::IdentifierExpression>("foo"), std::move(params)));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = a;
 if (_tint_tmp) {
   _tint_tmp = b;
diff --git a/src/writer/hlsl/generator_impl_bitcast_test.cc b/src/writer/hlsl/generator_impl_bitcast_test.cc
index ffe34d7..e7cd737 100644
--- a/src/writer/hlsl/generator_impl_bitcast_test.cc
+++ b/src/writer/hlsl/generator_impl_bitcast_test.cc
@@ -34,7 +34,7 @@
   auto id = std::make_unique<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&f32, std::move(id));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &bitcast)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
   EXPECT_EQ(result(), "asfloat(id)");
 }
 
@@ -43,7 +43,7 @@
   auto id = std::make_unique<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&i32, std::move(id));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &bitcast)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
   EXPECT_EQ(result(), "asint(id)");
 }
 
@@ -52,7 +52,7 @@
   auto id = std::make_unique<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&u32, std::move(id));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &bitcast)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
   EXPECT_EQ(result(), "asuint(id)");
 }
 
diff --git a/src/writer/hlsl/generator_impl_block_test.cc b/src/writer/hlsl/generator_impl_block_test.cc
index fd309e7..6d3549a 100644
--- a/src/writer/hlsl/generator_impl_block_test.cc
+++ b/src/writer/hlsl/generator_impl_block_test.cc
@@ -29,9 +29,9 @@
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &b)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &b)) << gen.error();
   EXPECT_EQ(result(), R"(  {
     discard;
   }
@@ -42,9 +42,9 @@
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitBlock(out(), &b)) << gen().error();
+  ASSERT_TRUE(gen.EmitBlock(out, &b)) << gen.error();
   EXPECT_EQ(result(), R"({
     discard;
   })");
diff --git a/src/writer/hlsl/generator_impl_break_test.cc b/src/writer/hlsl/generator_impl_break_test.cc
index 7185ca9..3eb2f7f 100644
--- a/src/writer/hlsl/generator_impl_break_test.cc
+++ b/src/writer/hlsl/generator_impl_break_test.cc
@@ -29,9 +29,9 @@
 TEST_F(HlslGeneratorImplTest_Break, Emit_Break) {
   ast::BreakStatement b;
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &b)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &b)) << gen.error();
   EXPECT_EQ(result(), "  break;\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_call_test.cc b/src/writer/hlsl/generator_impl_call_test.cc
index 63070e0..58a8a1e 100644
--- a/src/writer/hlsl/generator_impl_call_test.cc
+++ b/src/writer/hlsl/generator_impl_call_test.cc
@@ -37,9 +37,9 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &call)) << gen.error();
   EXPECT_EQ(result(), "my_func()");
 }
 
@@ -54,9 +54,9 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &call)) << gen.error();
   EXPECT_EQ(result(), "my_func(param1, param2)");
 }
 
@@ -72,9 +72,9 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
-  mod()->AddFunction(std::move(func));
-  gen().increment_indent();
-  ASSERT_TRUE(gen().EmitStatement(out(), &call)) << gen().error();
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitStatement(out, &call)) << gen.error();
   EXPECT_EQ(result(), "  my_func(param1, param2);\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_case_test.cc b/src/writer/hlsl/generator_impl_case_test.cc
index c0330b9..686e16e 100644
--- a/src/writer/hlsl/generator_impl_case_test.cc
+++ b/src/writer/hlsl/generator_impl_case_test.cc
@@ -40,9 +40,9 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitCase(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitCase(out, &c)) << gen.error();
   EXPECT_EQ(result(), R"(  case 5: {
     break;
   }
@@ -56,9 +56,9 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::make_unique<ast::BlockStatement>());
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitCase(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitCase(out, &c)) << gen.error();
   EXPECT_EQ(result(), R"(  case 5: {
     break;
   }
@@ -75,9 +75,9 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitCase(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitCase(out, &c)) << gen.error();
   EXPECT_EQ(result(), R"(  case 5: {
     /* fallthrough */
   }
@@ -95,9 +95,9 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 6));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitCase(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitCase(out, &c)) << gen.error();
   EXPECT_EQ(result(), R"(  case 5:
   case 6: {
     break;
@@ -112,9 +112,9 @@
   body->append(std::make_unique<ast::BreakStatement>());
   c.set_body(std::move(body));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitCase(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitCase(out, &c)) << gen.error();
   EXPECT_EQ(result(), R"(  default: {
     break;
   }
diff --git a/src/writer/hlsl/generator_impl_cast_test.cc b/src/writer/hlsl/generator_impl_cast_test.cc
index b92b104..9c88e51 100644
--- a/src/writer/hlsl/generator_impl_cast_test.cc
+++ b/src/writer/hlsl/generator_impl_cast_test.cc
@@ -36,7 +36,7 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &cast)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &cast)) << gen.error();
   EXPECT_EQ(result(), "float(id)");
 }
 
@@ -49,7 +49,7 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &cast)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &cast)) << gen.error();
   EXPECT_EQ(result(), "vector<float, 3>(id)");
 }
 
diff --git a/src/writer/hlsl/generator_impl_constructor_test.cc b/src/writer/hlsl/generator_impl_constructor_test.cc
index 4211ee8..1a953d0 100644
--- a/src/writer/hlsl/generator_impl_constructor_test.cc
+++ b/src/writer/hlsl/generator_impl_constructor_test.cc
@@ -40,7 +40,7 @@
   auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "false");
 }
 
@@ -49,7 +49,7 @@
   auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "-12345");
 }
 
@@ -58,7 +58,7 @@
   auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "56779u");
 }
 
@@ -69,7 +69,7 @@
       &f32, static_cast<float>((1 << 30) - 4));
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "1.07374182e+09f");
 }
 
@@ -83,7 +83,7 @@
 
   ast::TypeConstructorExpression expr(&f32, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "float(-1.20000004e-05f)");
 }
 
@@ -97,7 +97,7 @@
 
   ast::TypeConstructorExpression expr(&b, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "bool(true)");
 }
 
@@ -111,7 +111,7 @@
 
   ast::TypeConstructorExpression expr(&i32, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "int(-12345)");
 }
 
@@ -125,7 +125,7 @@
 
   ast::TypeConstructorExpression expr(&u32, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "uint(12345u)");
 }
 
@@ -146,7 +146,7 @@
 
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             "vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f)");
 }
@@ -158,7 +158,7 @@
   ast::ExpressionList values;
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "vector<float, 3>(0.0f)");
 }
 
@@ -194,7 +194,7 @@
 
   ast::TypeConstructorExpression expr(&mat, std::move(mat_values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
 
   // A matrix of type T with n columns and m rows can also be constructed from
   // n vectors of type T with m components.
@@ -233,7 +233,7 @@
 
   ast::TypeConstructorExpression expr(&ary, std::move(ary_values));
 
-  ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             std::string("{") +
                 "vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), " +
diff --git a/src/writer/hlsl/generator_impl_continue_test.cc b/src/writer/hlsl/generator_impl_continue_test.cc
index 170b7f7..7b548b9 100644
--- a/src/writer/hlsl/generator_impl_continue_test.cc
+++ b/src/writer/hlsl/generator_impl_continue_test.cc
@@ -29,9 +29,9 @@
 TEST_F(HlslGeneratorImplTest_Continue, Emit_Continue) {
   ast::ContinueStatement c;
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &c)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &c)) << gen.error();
   EXPECT_EQ(result(), "  continue;\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_discard_test.cc b/src/writer/hlsl/generator_impl_discard_test.cc
index 8bf84fd..422d39c 100644
--- a/src/writer/hlsl/generator_impl_discard_test.cc
+++ b/src/writer/hlsl/generator_impl_discard_test.cc
@@ -26,9 +26,9 @@
 TEST_F(HlslGeneratorImplTest_Discard, Emit_Discard) {
   ast::DiscardStatement stmt;
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  discard;\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_function_entry_point_data_test.cc b/src/writer/hlsl/generator_impl_function_entry_point_data_test.cc
index e089fca..9347e95 100644
--- a/src/writer/hlsl/generator_impl_function_entry_point_data_test.cc
+++ b/src/writer/hlsl/generator_impl_function_entry_point_data_test.cc
@@ -65,11 +65,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func =
@@ -87,13 +87,12 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
   EXPECT_EQ(result(), R"(struct vtx_main_in {
   float foo : TEXCOORD0;
   int bar : TEXCOORD1;
@@ -127,11 +126,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func =
@@ -149,13 +148,12 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
   EXPECT_EQ(result(), R"(struct vtx_main_out {
   float foo : TEXCOORD0;
   int bar : TEXCOORD1;
@@ -189,11 +187,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
@@ -210,13 +208,12 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
   EXPECT_EQ(result(), R"(struct main_in {
   float foo : TEXCOORD0;
   int bar : TEXCOORD1;
@@ -250,11 +247,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
@@ -271,13 +268,12 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
   EXPECT_EQ(result(), R"(struct main_out {
   float foo : SV_Target0;
   int bar : SV_Target1;
@@ -308,11 +304,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
@@ -329,14 +325,13 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_FALSE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
-  EXPECT_EQ(gen().error(), R"(invalid location variable for pipeline stage)");
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_FALSE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
+  EXPECT_EQ(gen.error(), R"(invalid location variable for pipeline stage)");
 }
 
 TEST_F(HlslGeneratorImplTest_EntryPoint,
@@ -361,11 +356,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
@@ -382,14 +377,13 @@
       std::make_unique<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_FALSE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
-  EXPECT_EQ(gen().error(), R"(invalid location variable for pipeline stage)");
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_FALSE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
+  EXPECT_EQ(gen.error(), R"(invalid location variable for pipeline stage)");
 }
 
 TEST_F(HlslGeneratorImplTest_EntryPoint,
@@ -425,11 +419,11 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  td().RegisterVariableForTesting(depth_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(depth_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
-  mod()->AddGlobalVariable(std::move(depth_var));
+  mod.AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(depth_var));
 
   ast::VariableList params;
   auto func =
@@ -446,13 +440,12 @@
           std::make_unique<ast::IdentifierExpression>("x"))));
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
   std::unordered_set<std::string> globals;
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().EmitEntryPointData(out(), func_ptr, globals))
-      << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.EmitEntryPointData(out, func_ptr, globals)) << gen.error();
   EXPECT_EQ(result(), R"(struct main_in {
   vector<float, 4> coord : SV_Position;
 };
diff --git a/src/writer/hlsl/generator_impl_function_test.cc b/src/writer/hlsl/generator_impl_function_test.cc
index 5f02e3a..3df6492 100644
--- a/src/writer/hlsl/generator_impl_function_test.cc
+++ b/src/writer/hlsl/generator_impl_function_test.cc
@@ -64,10 +64,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
-  gen().increment_indent();
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(  void my_func() {
     return;
   }
@@ -85,10 +85,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
-  gen().increment_indent();
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(  void GeometryShader_tint_0() {
     return;
   }
@@ -114,10 +114,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
-  gen().increment_indent();
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(  void my_func(float a, int b) {
     return;
   }
@@ -142,11 +142,11 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -161,10 +161,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct frag_main_in {
   float foo : TEXCOORD0;
 };
@@ -204,11 +204,11 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  td().RegisterVariableForTesting(depth_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(depth_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
-  mod()->AddGlobalVariable(std::move(depth_var));
+  mod.AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(depth_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -225,10 +225,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct frag_main_in {
   vector<float, 4> coord : SV_Position;
 };
@@ -261,8 +261,8 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -281,10 +281,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(cbuffer : register(b0) {
   vector<float, 4> coord;
 };
@@ -316,15 +316,15 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "uniforms", ast::StorageClass::kUniform, &s));
 
-  mod()->AddConstructedType(&s);
+  mod.AddConstructedType(&s);
 
   ast::VariableDecorationList decos;
   decos.push_back(std::make_unique<ast::BindingDecoration>(0, Source{}));
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -345,10 +345,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct Uniforms {
   vector<float, 4> coord;
 };
@@ -397,8 +397,8 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -417,10 +417,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
 
 void frag_main() {
@@ -465,8 +465,8 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -485,10 +485,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(ByteAddressBuffer coord : register(u0);
 
 void frag_main() {
@@ -533,9 +533,9 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
@@ -555,10 +555,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
 
 void frag_main() {
@@ -592,13 +592,13 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
   val_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(foo_var.get());
-  td().RegisterVariableForTesting(bar_var.get());
-  td().RegisterVariableForTesting(val_var.get());
+  td.RegisterVariableForTesting(foo_var.get());
+  td.RegisterVariableForTesting(bar_var.get());
+  td.RegisterVariableForTesting(val_var.get());
 
-  mod()->AddGlobalVariable(std::move(foo_var));
-  mod()->AddGlobalVariable(std::move(bar_var));
-  mod()->AddGlobalVariable(std::move(val_var));
+  mod.AddGlobalVariable(std::move(foo_var));
+  mod.AddGlobalVariable(std::move(bar_var));
+  mod.AddGlobalVariable(std::move(val_var));
 
   ast::VariableList params;
   params.push_back(std::make_unique<ast::Variable>(
@@ -617,7 +617,7 @@
       std::make_unique<ast::IdentifierExpression>("foo")));
   sub_func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(sub_func));
+  mod.AddFunction(std::move(sub_func));
 
   auto func_1 =
       std::make_unique<ast::Function>("ep_1", std::move(params), &void_type);
@@ -637,10 +637,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func_1->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func_1));
+  mod.AddFunction(std::move(func_1));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct ep_1_in {
   float foo : TEXCOORD0;
 };
@@ -680,9 +680,9 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(depth_var.get());
+  td.RegisterVariableForTesting(depth_var.get());
 
-  mod()->AddGlobalVariable(std::move(depth_var));
+  mod.AddGlobalVariable(std::move(depth_var));
 
   ast::VariableList params;
   params.push_back(std::make_unique<ast::Variable>(
@@ -695,7 +695,7 @@
       std::make_unique<ast::IdentifierExpression>("param")));
   sub_func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(sub_func));
+  mod.AddFunction(std::move(sub_func));
 
   auto func_1 =
       std::make_unique<ast::Function>("ep_1", std::move(params), &void_type);
@@ -715,10 +715,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func_1->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func_1));
+  mod.AddFunction(std::move(func_1));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct ep_1_out {
   float depth : SV_Depth;
 };
@@ -759,11 +759,11 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  td().RegisterVariableForTesting(depth_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(depth_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
-  mod()->AddGlobalVariable(std::move(depth_var));
+  mod.AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(depth_var));
 
   ast::VariableList params;
   params.push_back(std::make_unique<ast::Variable>(
@@ -781,7 +781,7 @@
       std::make_unique<ast::IdentifierExpression>("param")));
   sub_func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(sub_func));
+  mod.AddFunction(std::move(sub_func));
 
   auto func_1 =
       std::make_unique<ast::Function>("ep_1", std::move(params), &void_type);
@@ -801,10 +801,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func_1->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func_1));
+  mod.AddFunction(std::move(func_1));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct ep_1_in {
   vector<float, 4> coord : SV_Position;
 };
@@ -842,9 +842,9 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   params.push_back(std::make_unique<ast::Variable>(
@@ -859,7 +859,7 @@
           std::make_unique<ast::IdentifierExpression>("x"))));
   sub_func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(sub_func));
+  mod.AddFunction(std::move(sub_func));
 
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
                                               &void_type);
@@ -881,10 +881,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(cbuffer : register(b0) {
   vector<float, 4> coord;
 };
@@ -916,9 +916,9 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(coord_var.get());
 
-  mod()->AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
   params.push_back(std::make_unique<ast::Variable>(
@@ -933,7 +933,7 @@
           std::make_unique<ast::IdentifierExpression>("x"))));
   sub_func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(sub_func));
+  mod.AddFunction(std::move(sub_func));
 
   auto func = std::make_unique<ast::Function>("frag_main", std::move(params),
                                               &void_type);
@@ -955,10 +955,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
 
 float sub_func(float param) {
@@ -985,8 +985,8 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  td().RegisterVariableForTesting(bar_var.get());
-  mod()->AddGlobalVariable(std::move(bar_var));
+  td.RegisterVariableForTesting(bar_var.get());
+  mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
   auto func_1 =
@@ -1015,10 +1015,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func_1->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func_1));
+  mod.AddFunction(std::move(func_1));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct ep_1_out {
   float bar : SV_Target1;
 };
@@ -1044,9 +1044,9 @@
   func->add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kFragment, Source{}));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(void GeometryShader_tint_0() {
 }
 
@@ -1067,10 +1067,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"([numthreads(1, 1, 1)]
 void main() {
   return;
@@ -1095,10 +1095,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"([numthreads(2, 4, 6)]
 void main() {
   return;
@@ -1123,10 +1123,10 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  mod()->AddFunction(std::move(func));
-  gen().increment_indent();
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(  void my_func(float a[5]) {
     return;
   }
@@ -1180,9 +1180,9 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(0, Source{}));
   data_var->set_decorations(std::move(decos));
 
-  mod()->AddConstructedType(&s);
-  td().RegisterVariableForTesting(data_var.get());
-  mod()->AddGlobalVariable(std::move(data_var));
+  mod.AddConstructedType(&s);
+  td.RegisterVariableForTesting(data_var.get());
+  mod.AddGlobalVariable(std::move(data_var));
 
   {
     ast::VariableList params;
@@ -1202,7 +1202,7 @@
     body->append(std::make_unique<ast::ReturnStatement>());
     func->set_body(std::move(body));
 
-    mod()->AddFunction(std::move(func));
+    mod.AddFunction(std::move(func));
   }
 
   {
@@ -1223,11 +1223,11 @@
     body->append(std::make_unique<ast::ReturnStatement>());
     func->set_body(std::move(body));
 
-    mod()->AddFunction(std::move(func));
+    mod.AddFunction(std::move(func));
   }
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(struct Data {
   float d;
 };
diff --git a/src/writer/hlsl/generator_impl_identifier_test.cc b/src/writer/hlsl/generator_impl_identifier_test.cc
index bf38e8d..2c0bfd2 100644
--- a/src/writer/hlsl/generator_impl_identifier_test.cc
+++ b/src/writer/hlsl/generator_impl_identifier_test.cc
@@ -25,14 +25,14 @@
 
 TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
   ast::IdentifierExpression i("foo");
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
   EXPECT_EQ(result(), "foo");
 }
 
 TEST_F(HlslGeneratorImplTest_Identifier,
        EmitIdentifierExpression_Single_WithCollision) {
   ast::IdentifierExpression i("virtual");
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
   EXPECT_EQ(result(), "virtual_tint_0");
 }
 
diff --git a/src/writer/hlsl/generator_impl_if_test.cc b/src/writer/hlsl/generator_impl_if_test.cc
index aa2c07a..f531cd6 100644
--- a/src/writer/hlsl/generator_impl_if_test.cc
+++ b/src/writer/hlsl/generator_impl_if_test.cc
@@ -32,9 +32,9 @@
   body->append(std::make_unique<ast::ReturnStatement>());
 
   ast::IfStatement i(std::move(cond), std::move(body));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &i)) << gen.error();
   EXPECT_EQ(result(), R"(  if (cond) {
     return;
   }
@@ -57,9 +57,9 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &i)) << gen.error();
   EXPECT_EQ(result(), R"(  if (cond) {
     return;
   } else {
@@ -84,9 +84,9 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &i)) << gen.error();
   EXPECT_EQ(result(), R"(  if (cond) {
     return;
   } else {
@@ -116,9 +116,9 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &i)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &i)) << gen.error();
   EXPECT_EQ(result(), R"(  if (cond) {
     return;
   } else {
diff --git a/src/writer/hlsl/generator_impl_import_test.cc b/src/writer/hlsl/generator_impl_import_test.cc
index 4cd8a61..152a64a 100644
--- a/src/writer/hlsl/generator_impl_import_test.cc
+++ b/src/writer/hlsl/generator_impl_import_test.cc
@@ -47,8 +47,7 @@
   return out;
 }
 
-using HlslImportData_SingleParamTest =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_SingleParamTest = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_SingleParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -61,8 +60,8 @@
   auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
   ast::CallExpression expr(std::move(ident), std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1.00000000f)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@@ -93,8 +92,7 @@
                                          HlslImportData{"tanh", "tanh"},
                                          HlslImportData{"trunc", "trunc"}));
 
-using HlslImportData_SingleIntParamTest =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_SingleIntParamTest = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_SingleIntParamTest, IntScalar) {
   auto param = GetParam();
 
@@ -108,16 +106,15 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
                          HlslImportData_SingleIntParamTest,
                          testing::Values(HlslImportData{"abs", "abs"}));
 
-using HlslImportData_DualParamTest =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_DualParamTest = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_DualParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -133,8 +130,8 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             std::string(param.hlsl_name) + "(1.00000000f, 2.00000000f)");
 }
@@ -148,8 +145,7 @@
                                          HlslImportData{"reflect", "reflect"},
                                          HlslImportData{"step", "step"}));
 
-using HlslImportData_DualParam_VectorTest =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_DualParam_VectorTest = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
   auto param = GetParam();
 
@@ -181,8 +177,8 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             std::string(param.hlsl_name) +
                 "(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), "
@@ -192,8 +188,7 @@
                          HlslImportData_DualParam_VectorTest,
                          testing::Values(HlslImportData{"cross", "cross"}));
 
-using HlslImportData_DualParam_Int_Test =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_DualParam_Int_Test = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
   auto param = GetParam();
 
@@ -209,8 +204,8 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@@ -218,8 +213,7 @@
                          testing::Values(HlslImportData{"max", "max"},
                                          HlslImportData{"min", "min"}));
 
-using HlslImportData_TripleParamTest =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_TripleParamTest = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -237,8 +231,8 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) +
                           "(1.00000000f, 2.00000000f, 3.00000000f)");
 }
@@ -254,8 +248,7 @@
   FAIL();
 }
 
-using HlslImportData_TripleParam_Int_Test =
-    TestHelperBase<testing::TestWithParam<HlslImportData>>;
+using HlslImportData_TripleParam_Int_Test = TestParamHelper<HlslImportData>;
 TEST_P(HlslImportData_TripleParam_Int_Test, IntScalar) {
   auto param = GetParam();
 
@@ -273,8 +266,8 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2, 3)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@@ -295,12 +288,12 @@
       std::make_unique<ast::IdentifierExpression>("determinant"),
       std::move(params));
 
-  mod()->AddGlobalVariable(std::move(var));
+  mod.AddGlobalVariable(std::move(var));
 
   // Register the global
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitCall(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), std::string("determinant(var)"));
 }
 
diff --git a/src/writer/hlsl/generator_impl_intrinsic_test.cc b/src/writer/hlsl/generator_impl_intrinsic_test.cc
index 78db9f9..37e4eba 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_test.cc
@@ -36,10 +36,10 @@
   out << data.hlsl_name;
   return out;
 }
-using HlslIntrinsicTest = TestHelperBase<testing::TestWithParam<IntrinsicData>>;
+using HlslIntrinsicTest = TestParamHelper<IntrinsicData>;
 TEST_P(HlslIntrinsicTest, Emit) {
   auto param = GetParam();
-  EXPECT_EQ(gen().generate_intrinsic_name(param.intrinsic), param.hlsl_name);
+  EXPECT_EQ(gen.generate_intrinsic_name(param.intrinsic), param.hlsl_name);
 }
 INSTANTIATE_TEST_SUITE_P(
     HlslGeneratorImplTest_Intrinsic,
@@ -89,22 +89,22 @@
       std::make_unique<ast::IdentifierExpression>("outer_product"),
       std::move(params));
 
-  td().RegisterVariableForTesting(a.get());
-  td().RegisterVariableForTesting(b.get());
+  td.RegisterVariableForTesting(a.get());
+  td.RegisterVariableForTesting(b.get());
 
-  mod()->AddGlobalVariable(std::move(a));
-  mod()->AddGlobalVariable(std::move(b));
+  mod.AddGlobalVariable(std::move(a));
+  mod.AddGlobalVariable(std::move(b));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&call)) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
-  gen().increment_indent();
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &call)) << gen.error();
   EXPECT_EQ(result(), "  float3x2(a * b[0], a * b[1], a * b[2])");
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Bad_Name) {
-  EXPECT_EQ(gen().generate_intrinsic_name(ast::Intrinsic::kNone), "");
+  EXPECT_EQ(gen.generate_intrinsic_name(ast::Intrinsic::kNone), "");
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
@@ -121,13 +121,13 @@
   ast::Variable v1("param1", ast::StorageClass::kFunction, &vec);
   ast::Variable v2("param2", ast::StorageClass::kFunction, &vec);
 
-  td().RegisterVariableForTesting(&v1);
-  td().RegisterVariableForTesting(&v2);
+  td.RegisterVariableForTesting(&v1);
+  td.RegisterVariableForTesting(&v2);
 
-  ASSERT_TRUE(td().DetermineResultType(&call)) << td().error();
+  ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
-  gen().increment_indent();
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &call)) << gen.error();
   EXPECT_EQ(result(), "  dot(param1, param2)");
 }
 
diff --git a/src/writer/hlsl/generator_impl_loop_test.cc b/src/writer/hlsl/generator_impl_loop_test.cc
index 576b7b2..7496064 100644
--- a/src/writer/hlsl/generator_impl_loop_test.cc
+++ b/src/writer/hlsl/generator_impl_loop_test.cc
@@ -38,9 +38,9 @@
   body->append(std::make_unique<ast::DiscardStatement>());
 
   ast::LoopStatement l(std::move(body), {});
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &l)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &l)) << gen.error();
   EXPECT_EQ(result(), R"(  for(;;) {
     discard;
   }
@@ -55,9 +55,9 @@
   continuing->append(std::make_unique<ast::ReturnStatement>());
 
   ast::LoopStatement l(std::move(body), std::move(continuing));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &l)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &l)) << gen.error();
   EXPECT_EQ(result(), R"(  {
     bool tint_hlsl_is_first_1 = true;
     for(;;) {
@@ -95,9 +95,9 @@
       std::move(lhs), std::move(rhs)));
 
   ast::LoopStatement outer(std::move(body), std::move(continuing));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &outer)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &outer)) << gen.error();
   EXPECT_EQ(result(), R"(  {
     bool tint_hlsl_is_first_1 = true;
     for(;;) {
@@ -165,9 +165,9 @@
       std::move(lhs), std::move(rhs)));
 
   ast::LoopStatement outer(std::move(body), std::move(continuing));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &outer)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &outer)) << gen.error();
   EXPECT_EQ(result(), R"(  {
     bool tint_hlsl_is_first_1 = true;
     float lhs;
diff --git a/src/writer/hlsl/generator_impl_member_accessor_test.cc b/src/writer/hlsl/generator_impl_member_accessor_test.cc
index 5a345c2..57112e8 100644
--- a/src/writer/hlsl/generator_impl_member_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_member_accessor_test.cc
@@ -69,12 +69,12 @@
 
   ast::MemberAccessorExpression expr(std::move(str), std::move(mem));
 
-  td().RegisterVariableForTesting(str_var.get());
-  gen().register_global(str_var.get());
-  mod()->AddGlobalVariable(std::move(str_var));
+  td.RegisterVariableForTesting(str_var.get());
+  gen.register_global(str_var.get());
+  mod.AddGlobalVariable(std::move(str_var));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "str.mem");
 }
 
@@ -117,14 +117,14 @@
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("b"));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load(4))");
 }
 
@@ -167,14 +167,14 @@
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asint(data.Load(0))");
 }
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -225,17 +225,17 @@
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  td().RegisterVariableForTesting(b_var.get());
-  gen().register_global(coord_var.get());
-  gen().register_global(b_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
-  mod()->AddGlobalVariable(std::move(b_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  td.RegisterVariableForTesting(b_var.get());
+  gen.register_global(coord_var.get());
+  gen.register_global(b_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
+  mod.AddGlobalVariable(std::move(b_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&assign));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(), R"(matrix<float, 3, 2> _tint_tmp = b;
 data.Store3(4 + 0, asuint(_tint_tmp[0]));
 data.Store3(4 + 16, asuint(_tint_tmp[1]));
@@ -289,14 +289,14 @@
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&assign));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(
       result(),
       R"(matrix<float, 3, 2> _tint_tmp = matrix<float, 3, 2>(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
@@ -346,14 +346,14 @@
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             "asfloat(matrix<uint, 2, 3>(data.Load2(4 + 0), data.Load2(4 + 8), "
             "data.Load2(4 + 16)))");
@@ -403,14 +403,14 @@
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(
       result(),
       "asfloat(matrix<uint, 3, 2>(data.Load3(4 + 0), data.Load3(4 + 16)))");
@@ -451,14 +451,14 @@
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(),
             "asfloat(matrix<uint, 3, 3>(data.Load3(0 + 0), data.Load3(0 + 16), "
             "data.Load3(0 + 32)))");
@@ -510,14 +510,14 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr));
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + (16 * 2) + 16))");
 }
 
@@ -560,14 +560,14 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asint(data.Load((4 * 2) + 0))");
 }
 
@@ -618,14 +618,14 @@
           std::make_unique<ast::ScalarConstructorExpression>(
               std::make_unique<ast::SintLiteral>(&i32, 3))));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
-  ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asint(data.Load((4 * ((2 + 4) - 3)) + 0))");
 }
 
@@ -665,11 +665,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &s));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lhs = std::make_unique<ast::MemberAccessorExpression>(
       std::make_unique<ast::IdentifierExpression>("data"),
@@ -678,8 +678,8 @@
       std::make_unique<ast::FloatLiteral>(&f32, 2.0f));
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign));
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(), R"(data.Store(4, asuint(2.00000000f));
 )");
 }
@@ -717,11 +717,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &s));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lhs = std::make_unique<ast::ArrayAccessorExpression>(
       std::make_unique<ast::MemberAccessorExpression>(
@@ -733,8 +733,8 @@
       std::make_unique<ast::SintLiteral>(&i32, 2));
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign)) << td().error();
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(), R"(data.Store((4 * 2) + 0, asuint(2));
 )");
 }
@@ -775,11 +775,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &s));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lhs = std::make_unique<ast::MemberAccessorExpression>(
       std::make_unique<ast::IdentifierExpression>("data"),
@@ -788,8 +788,8 @@
       std::make_unique<ast::SintLiteral>(&i32, 2));
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign));
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(), R"(data.Store(0, asuint(2));
 )");
 }
@@ -832,18 +832,18 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &s));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   ast::MemberAccessorExpression expr(
       std::make_unique<ast::IdentifierExpression>("data"),
       std::make_unique<ast::IdentifierExpression>("b"));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr));
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load3(16))");
 }
 
@@ -885,11 +885,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &s));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lit1 = std::make_unique<ast::FloatLiteral>(&f32, 1.f);
   auto lit2 = std::make_unique<ast::FloatLiteral>(&f32, 2.f);
@@ -910,8 +910,8 @@
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign));
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(
       result(),
       R"(data.Store3(16, asuint(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f)));
@@ -974,11 +974,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   ast::MemberAccessorExpression expr(
       std::make_unique<ast::ArrayAccessorExpression>(
@@ -989,8 +989,8 @@
               std::make_unique<ast::SintLiteral>(&i32, 2))),
       std::make_unique<ast::IdentifierExpression>("b"));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr));
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0))");
 }
 
@@ -1050,11 +1050,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   ast::MemberAccessorExpression expr(
       std::make_unique<ast::MemberAccessorExpression>(
@@ -1067,8 +1067,8 @@
           std::make_unique<ast::IdentifierExpression>("b")),
       std::make_unique<ast::IdentifierExpression>("xy"));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr));
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0)).xy");
 }
 
@@ -1129,11 +1129,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   ast::MemberAccessorExpression expr(
       std::make_unique<ast::MemberAccessorExpression>(
@@ -1146,8 +1146,8 @@
           std::make_unique<ast::IdentifierExpression>("b")),
       std::make_unique<ast::IdentifierExpression>("g"));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr));
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))");
 }
 
@@ -1207,11 +1207,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   ast::ArrayAccessorExpression expr(
       std::make_unique<ast::MemberAccessorExpression>(
@@ -1225,8 +1225,8 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td().DetermineResultType(&expr));
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&expr));
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
   EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))");
 }
 
@@ -1286,11 +1286,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lhs = std::make_unique<ast::MemberAccessorExpression>(
       std::make_unique<ast::ArrayAccessorExpression>(
@@ -1317,8 +1317,8 @@
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign));
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(
       result(),
       R"(data.Store3(16 + (32 * 2) + 0, asuint(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f)));
@@ -1381,11 +1381,11 @@
       std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
           "data", ast::StorageClass::kStorageBuffer, &pre_struct));
 
-  td().RegisterVariableForTesting(coord_var.get());
-  gen().register_global(coord_var.get());
-  mod()->AddGlobalVariable(std::move(coord_var));
+  td.RegisterVariableForTesting(coord_var.get());
+  gen.register_global(coord_var.get());
+  mod.AddGlobalVariable(std::move(coord_var));
 
-  ASSERT_TRUE(td().Determine()) << td().error();
+  ASSERT_TRUE(td.Determine()) << td.error();
 
   auto lhs = std::make_unique<ast::MemberAccessorExpression>(
       std::make_unique<ast::MemberAccessorExpression>(
@@ -1403,8 +1403,8 @@
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ASSERT_TRUE(td().DetermineResultType(&assign));
-  ASSERT_TRUE(gen().EmitStatement(out(), &assign)) << gen().error();
+  ASSERT_TRUE(td.DetermineResultType(&assign));
+  ASSERT_TRUE(gen.EmitStatement(out, &assign)) << gen.error();
   EXPECT_EQ(result(),
             R"(data.Store((4 * 1) + 16 + (32 * 2) + 0, asuint(1.00000000f));
 )");
diff --git a/src/writer/hlsl/generator_impl_module_constant_test.cc b/src/writer/hlsl/generator_impl_module_constant_test.cc
index a63b7db..93dd49c 100644
--- a/src/writer/hlsl/generator_impl_module_constant_test.cc
+++ b/src/writer/hlsl/generator_impl_module_constant_test.cc
@@ -51,8 +51,7 @@
   var->set_constructor(
       std::make_unique<ast::TypeConstructorExpression>(&ary, std::move(exprs)));
 
-  ASSERT_TRUE(gen().EmitProgramConstVariable(out(), var.get()))
-      << gen().error();
+  ASSERT_TRUE(gen.EmitProgramConstVariable(out, var.get())) << gen.error();
   EXPECT_EQ(
       result(),
       "static const float pos[3] = {1.00000000f, 2.00000000f, 3.00000000f};\n");
@@ -71,8 +70,7 @@
   var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
 
-  ASSERT_TRUE(gen().EmitProgramConstVariable(out(), var.get()))
-      << gen().error();
+  ASSERT_TRUE(gen.EmitProgramConstVariable(out, var.get())) << gen.error();
   EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
 #define WGSL_SPEC_CONSTANT_23 3.00000000f
 #endif
@@ -92,8 +90,7 @@
   var->set_decorations(std::move(decos));
   var->set_is_const(true);
 
-  ASSERT_TRUE(gen().EmitProgramConstVariable(out(), var.get()))
-      << gen().error();
+  ASSERT_TRUE(gen.EmitProgramConstVariable(out, var.get())) << gen.error();
   EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
 #error spec constant required for constant id 23
 #endif
diff --git a/src/writer/hlsl/generator_impl_return_test.cc b/src/writer/hlsl/generator_impl_return_test.cc
index d3b785a..ee90420 100644
--- a/src/writer/hlsl/generator_impl_return_test.cc
+++ b/src/writer/hlsl/generator_impl_return_test.cc
@@ -29,18 +29,18 @@
 
 TEST_F(HlslGeneratorImplTest_Return, Emit_Return) {
   ast::ReturnStatement r;
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &r)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &r)) << gen.error();
   EXPECT_EQ(result(), "  return;\n");
 }
 
 TEST_F(HlslGeneratorImplTest_Return, Emit_ReturnWithValue) {
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::ReturnStatement r(std::move(expr));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &r)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &r)) << gen.error();
   EXPECT_EQ(result(), "  return expr;\n");
 }
 
diff --git a/src/writer/hlsl/generator_impl_switch_test.cc b/src/writer/hlsl/generator_impl_switch_test.cc
index c8e7771..3768c0d 100644
--- a/src/writer/hlsl/generator_impl_switch_test.cc
+++ b/src/writer/hlsl/generator_impl_switch_test.cc
@@ -52,9 +52,9 @@
 
   auto cond = std::make_unique<ast::IdentifierExpression>("cond");
   ast::SwitchStatement s(std::move(cond), std::move(body));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &s)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &s)) << gen.error();
   EXPECT_EQ(result(), R"(  switch(cond) {
     case 5: {
       break;
diff --git a/src/writer/hlsl/generator_impl_test.cc b/src/writer/hlsl/generator_impl_test.cc
index 26b7003..22a6613 100644
--- a/src/writer/hlsl/generator_impl_test.cc
+++ b/src/writer/hlsl/generator_impl_test.cc
@@ -31,9 +31,9 @@
   ast::type::VoidType void_type;
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
-  mod()->AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  ASSERT_TRUE(gen().Generate(out())) << gen().error();
+  ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"(void my_func() {
 }
 
@@ -41,22 +41,22 @@
 }
 
 TEST_F(HlslGeneratorImplTest, InputStructName) {
-  ASSERT_EQ(gen().generate_name("func_main_in"), "func_main_in");
+  ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 }
 
 TEST_F(HlslGeneratorImplTest, InputStructName_ConflictWithExisting) {
   // Register the struct name as existing.
-  auto* namer = gen().namer_for_testing();
+  auto* namer = gen.namer_for_testing();
   namer->NameFor("func_main_out");
 
-  ASSERT_EQ(gen().generate_name("func_main_out"), "func_main_out_0");
+  ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_0");
 }
 
 TEST_F(HlslGeneratorImplTest, NameConflictWith_InputStructName) {
-  ASSERT_EQ(gen().generate_name("func_main_in"), "func_main_in");
+  ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 
   ast::IdentifierExpression ident("func_main_in");
-  ASSERT_TRUE(gen().EmitIdentifier(pre(), out(), &ident));
+  ASSERT_TRUE(gen.EmitIdentifier(pre, out, &ident));
   EXPECT_EQ(result(), "func_main_in_0");
 }
 
@@ -68,11 +68,10 @@
   out << data.builtin;
   return out;
 }
-using HlslBuiltinConversionTest =
-    TestHelperBase<testing::TestWithParam<HlslBuiltinData>>;
+using HlslBuiltinConversionTest = TestParamHelper<HlslBuiltinData>;
 TEST_P(HlslBuiltinConversionTest, Emit) {
   auto params = GetParam();
-  EXPECT_EQ(gen().builtin_to_attribute(params.builtin),
+  EXPECT_EQ(gen.builtin_to_attribute(params.builtin),
             std::string(params.attribute_name));
 }
 INSTANTIATE_TEST_SUITE_P(
diff --git a/src/writer/hlsl/generator_impl_type_test.cc b/src/writer/hlsl/generator_impl_type_test.cc
index 8cac130..ecab2d4 100644
--- a/src/writer/hlsl/generator_impl_type_test.cc
+++ b/src/writer/hlsl/generator_impl_type_test.cc
@@ -47,7 +47,7 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias("alias", &f32);
 
-  ASSERT_TRUE(gen().EmitType(out(), &alias, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &alias, "")) << gen.error();
   EXPECT_EQ(result(), "alias");
 }
 
@@ -55,7 +55,7 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias("bool", &f32);
 
-  ASSERT_TRUE(gen().EmitType(out(), &alias, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &alias, "")) << gen.error();
   EXPECT_EQ(result(), "bool_tint_0");
 }
 
@@ -63,7 +63,7 @@
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ASSERT_TRUE(gen().EmitType(out(), &a, "ary")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &a, "ary")) << gen.error();
   EXPECT_EQ(result(), "bool ary[4]");
 }
 
@@ -72,7 +72,7 @@
   ast::type::ArrayType a(&b, 4);
   ast::type::ArrayType c(&a, 5);
 
-  ASSERT_TRUE(gen().EmitType(out(), &c, "ary")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &c, "ary")) << gen.error();
   EXPECT_EQ(result(), "bool ary[5][4]");
 }
 
@@ -84,7 +84,7 @@
   ast::type::ArrayType c(&a, 5);
   ast::type::ArrayType d(&c);
 
-  ASSERT_TRUE(gen().EmitType(out(), &c, "ary")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &c, "ary")) << gen.error();
   EXPECT_EQ(result(), "bool ary[5][4][1]");
 }
 
@@ -94,7 +94,7 @@
   ast::type::ArrayType c(&a, 5);
   ast::type::ArrayType d(&c, 6);
 
-  ASSERT_TRUE(gen().EmitType(out(), &d, "ary")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &d, "ary")) << gen.error();
   EXPECT_EQ(result(), "bool ary[6][5][4]");
 }
 
@@ -102,7 +102,7 @@
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ASSERT_TRUE(gen().EmitType(out(), &a, "bool")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &a, "bool")) << gen.error();
   EXPECT_EQ(result(), "bool bool_tint_0[4]");
 }
 
@@ -110,7 +110,7 @@
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ASSERT_TRUE(gen().EmitType(out(), &a, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &a, "")) << gen.error();
   EXPECT_EQ(result(), "bool[4]");
 }
 
@@ -118,7 +118,7 @@
   ast::type::BoolType b;
   ast::type::ArrayType a(&b);
 
-  ASSERT_TRUE(gen().EmitType(out(), &a, "ary")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &a, "ary")) << gen.error();
   EXPECT_EQ(result(), "bool ary[]");
 }
 
@@ -127,28 +127,28 @@
   ast::type::BoolType b;
   ast::type::ArrayType a(&b);
 
-  ASSERT_TRUE(gen().EmitType(out(), &a, "double")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &a, "double")) << gen.error();
   EXPECT_EQ(result(), "bool double_tint_0[]");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_Bool) {
   ast::type::BoolType b;
 
-  ASSERT_TRUE(gen().EmitType(out(), &b, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &b, "")) << gen.error();
   EXPECT_EQ(result(), "bool");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_F32) {
   ast::type::F32Type f32;
 
-  ASSERT_TRUE(gen().EmitType(out(), &f32, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &f32, "")) << gen.error();
   EXPECT_EQ(result(), "float");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_I32) {
   ast::type::I32Type i32;
 
-  ASSERT_TRUE(gen().EmitType(out(), &i32, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &i32, "")) << gen.error();
   EXPECT_EQ(result(), "int");
 }
 
@@ -156,7 +156,7 @@
   ast::type::F32Type f32;
   ast::type::MatrixType m(&f32, 3, 2);
 
-  ASSERT_TRUE(gen().EmitType(out(), &m, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &m, "")) << gen.error();
   EXPECT_EQ(result(), "matrix<float, 3, 2>");
 }
 
@@ -165,7 +165,7 @@
   ast::type::F32Type f32;
   ast::type::PointerType p(&f32, ast::StorageClass::kWorkgroup);
 
-  ASSERT_TRUE(gen().EmitType(out(), &p, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &p, "")) << gen.error();
   EXPECT_EQ(result(), "float*");
 }
 
@@ -188,7 +188,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ASSERT_TRUE(gen().EmitStructType(out(), &s, "S")) << gen().error();
+  ASSERT_TRUE(gen.EmitStructType(out, &s, "S")) << gen.error();
   EXPECT_EQ(result(), R"(struct S {
   int a;
   float b;
@@ -215,7 +215,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), "S");
 }
 
@@ -246,7 +246,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), R"(struct {
   int8_t pad_0[4];
   int a;
@@ -274,7 +274,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ASSERT_TRUE(gen().EmitStructType(out(), &s, "S")) << gen().error();
+  ASSERT_TRUE(gen.EmitStructType(out, &s, "S")) << gen.error();
   EXPECT_EQ(result(), R"(struct S {
   int double_tint_0;
   float float_tint_0;
@@ -305,7 +305,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ASSERT_TRUE(gen().EmitStructType(out(), &s, "B")) << gen().error();
+  ASSERT_TRUE(gen.EmitStructType(out, &s, "B")) << gen.error();
   EXPECT_EQ(result(), R"(struct B {
   int a;
   float b;
@@ -315,7 +315,7 @@
 TEST_F(HlslGeneratorImplTest_Type, EmitType_U32) {
   ast::type::U32Type u32;
 
-  ASSERT_TRUE(gen().EmitType(out(), &u32, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &u32, "")) << gen.error();
   EXPECT_EQ(result(), "uint");
 }
 
@@ -323,28 +323,28 @@
   ast::type::F32Type f32;
   ast::type::VectorType v(&f32, 3);
 
-  ASSERT_TRUE(gen().EmitType(out(), &v, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &v, "")) << gen.error();
   EXPECT_EQ(result(), "vector<float, 3>");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_Void) {
   ast::type::VoidType v;
 
-  ASSERT_TRUE(gen().EmitType(out(), &v, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &v, "")) << gen.error();
   EXPECT_EQ(result(), "void");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitSampler) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kSampler);
 
-  ASSERT_TRUE(gen().EmitType(out(), &sampler, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &sampler, "")) << gen.error();
   EXPECT_EQ(result(), "SamplerState");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitSamplerComparison) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kComparisonSampler);
 
-  ASSERT_TRUE(gen().EmitType(out(), &sampler, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &sampler, "")) << gen.error();
   EXPECT_EQ(result(), "SamplerComparisonState");
 }
 
@@ -356,14 +356,13 @@
   out << data.dim;
   return out;
 }
-using HlslDepthtexturesTest =
-    TestHelperBase<testing::TestWithParam<HlslDepthTextureData>>;
+using HlslDepthtexturesTest = TestParamHelper<HlslDepthTextureData>;
 TEST_P(HlslDepthtexturesTest, Emit) {
   auto params = GetParam();
 
   ast::type::DepthTextureType s(params.dim);
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -385,15 +384,14 @@
   out << data.dim;
   return out;
 }
-using HlslSampledtexturesTest =
-    TestHelperBase<testing::TestWithParam<HlslTextureData>>;
+using HlslSampledtexturesTest = TestParamHelper<HlslTextureData>;
 TEST_P(HlslSampledtexturesTest, Emit) {
   auto params = GetParam();
 
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(params.dim, &f32);
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -415,7 +413,7 @@
   ast::type::F32Type f32;
   ast::type::MultisampledTextureType s(ast::type::TextureDimension::k2d, &f32);
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), "Texture2D");
 }
 
@@ -429,8 +427,7 @@
   out << data.dim << (data.ro ? "ReadOnly" : "WriteOnly");
   return out;
 }
-using HlslStoragetexturesTest =
-    TestHelperBase<testing::TestWithParam<HlslStorageTextureData>>;
+using HlslStoragetexturesTest = TestParamHelper<HlslStorageTextureData>;
 TEST_P(HlslStoragetexturesTest, Emit) {
   auto params = GetParam();
 
@@ -439,7 +436,7 @@
                                             : ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
 
-  ASSERT_TRUE(gen().EmitType(out(), &s, "")) << gen().error();
+  ASSERT_TRUE(gen.EmitType(out, &s, "")) << gen.error();
   EXPECT_EQ(result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
diff --git a/src/writer/hlsl/generator_impl_unary_op_test.cc b/src/writer/hlsl/generator_impl_unary_op_test.cc
index b723132..751e23f 100644
--- a/src/writer/hlsl/generator_impl_unary_op_test.cc
+++ b/src/writer/hlsl/generator_impl_unary_op_test.cc
@@ -33,14 +33,14 @@
   out << data.op;
   return out;
 }
-using HlslUnaryOpTest = TestHelperBase<testing::TestWithParam<UnaryOpData>>;
+using HlslUnaryOpTest = TestParamHelper<UnaryOpData>;
 TEST_P(HlslUnaryOpTest, Emit) {
   auto params = GetParam();
 
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::UnaryOpExpression op(params.op, std::move(expr));
 
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &op)) << gen().error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, &op)) << gen.error();
   EXPECT_EQ(result(), std::string(params.name) + "(expr)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp,
diff --git a/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc b/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
index f18e466..81df764 100644
--- a/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
@@ -38,9 +38,9 @@
       std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
 
   ast::VariableDeclStatement stmt(std::move(var));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  float a;\n");
 }
 
@@ -51,9 +51,9 @@
   var->set_is_const(true);
 
   ast::VariableDeclStatement stmt(std::move(var));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  const float a;\n");
 }
 
@@ -65,9 +65,9 @@
       std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &ary);
 
   ast::VariableDeclStatement stmt(std::move(var));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  float a[5];\n");
 }
 
@@ -78,9 +78,9 @@
       std::make_unique<ast::Variable>("a", ast::StorageClass::kFunction, &f32);
 
   ast::VariableDeclStatement stmt(std::move(var));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  float a;\n");
 }
 
@@ -90,9 +90,9 @@
       std::make_unique<ast::Variable>("a", ast::StorageClass::kPrivate, &f32);
 
   ast::VariableDeclStatement stmt(std::move(var));
-  gen().increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), "  float a;\n");
 }
 
@@ -106,7 +106,7 @@
   var->set_constructor(std::move(ident));
 
   ast::VariableDeclStatement stmt(std::move(var));
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), R"(float a = initializer;
 )");
 }
@@ -125,7 +125,7 @@
   var->set_constructor(std::move(zero_vec));
 
   ast::VariableDeclStatement stmt(std::move(var));
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(result(), R"(vector<float, 3> a = vector<float, 3>(0.0f);
 )");
 }
@@ -144,7 +144,7 @@
   var->set_constructor(std::move(zero_mat));
 
   ast::VariableDeclStatement stmt(std::move(var));
-  ASSERT_TRUE(gen().EmitStatement(out(), &stmt)) << gen().error();
+  ASSERT_TRUE(gen.EmitStatement(out, &stmt)) << gen.error();
   EXPECT_EQ(
       result(),
       R"(matrix<float, 3, 2> a = matrix<float, 3, 2>(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
diff --git a/src/writer/hlsl/test_helper.h b/src/writer/hlsl/test_helper.h
index 93dcca2..d83cee1 100644
--- a/src/writer/hlsl/test_helper.h
+++ b/src/writer/hlsl/test_helper.h
@@ -32,40 +32,34 @@
 template <typename T>
 class TestHelperBase : public T {
  public:
-  TestHelperBase() : td_(&ctx_, &mod_), impl_(&mod_) {}
+  TestHelperBase() : td(&ctx, &mod), gen(&ctx, &mod) {}
   ~TestHelperBase() = default;
 
-  /// @returns the generator implementation
-  GeneratorImpl& gen() { return impl_; }
-
-  /// @returns the module
-  ast::Module* mod() { return &mod_; }
-
-  /// @returns the type determiner
-  TypeDeterminer& td() { return td_; }
-
-  /// @returns the output stream
-  std::ostream& out() { return out_; }
-
-  /// @returns the pre stream
-  std::ostream& pre() { return pre_; }
-
   /// @returns the result string
-  std::string result() const { return out_.str(); }
+  std::string result() const { return out.str(); }
 
   /// @returns the pre result string
-  std::string pre_result() const { return pre_.str(); }
+  std::string pre_result() const { return pre.str(); }
 
- private:
-  Context ctx_;
-  ast::Module mod_;
-  TypeDeterminer td_;
-  GeneratorImpl impl_;
-  std::ostringstream out_;
-  std::ostringstream pre_;
+  /// The context
+  Context ctx;
+  /// The module
+  ast::Module mod;
+  /// The type determiner
+  TypeDeterminer td;
+  /// The generator
+  GeneratorImpl gen;
+
+  /// The output stream
+  std::ostringstream out;
+  /// The pre-output stream
+  std::ostringstream pre;
 };
 using TestHelper = TestHelperBase<testing::Test>;
 
+template <typename T>
+using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
+
 }  // namespace hlsl
 }  // namespace writer
 }  // namespace tint
diff --git a/src/writer/msl/generator.cc b/src/writer/msl/generator.cc
index 46fa073..418735e 100644
--- a/src/writer/msl/generator.cc
+++ b/src/writer/msl/generator.cc
@@ -22,13 +22,17 @@
 
 Generator::Generator(ast::Module module)
     : Text(std::move(module)),
-      impl_(std::make_unique<GeneratorImpl>(&module_)) {}
+      impl_(std::make_unique<GeneratorImpl>(ctx_, &module_)) {}
+
+Generator::Generator(Context* ctx, ast::Module module)
+    : Text(ctx, std::move(module)),
+      impl_(std::make_unique<GeneratorImpl>(ctx_, &module_)) {}
 
 Generator::~Generator() = default;
 
 void Generator::Reset() {
   set_error("");
-  impl_ = std::make_unique<GeneratorImpl>(&module_);
+  impl_ = std::make_unique<GeneratorImpl>(ctx_, &module_);
 }
 
 bool Generator::Generate() {
diff --git a/src/writer/msl/generator.h b/src/writer/msl/generator.h
index d0a9de2..19bf085 100644
--- a/src/writer/msl/generator.h
+++ b/src/writer/msl/generator.h
@@ -29,8 +29,13 @@
 class Generator : public Text {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module the module to convert
   explicit Generator(ast::Module module);
+  /// Constructor
+  /// @param ctx the context object, must be non-null
+  /// @param module the module to convert
+  Generator(Context* ctx, ast::Module module);
   ~Generator() override;
 
   /// Resets the generator
diff --git a/src/writer/msl/generator_impl.cc b/src/writer/msl/generator_impl.cc
index cd78aff..e07b6a6 100644
--- a/src/writer/msl/generator_impl.cc
+++ b/src/writer/msl/generator_impl.cc
@@ -92,7 +92,8 @@
 
 }  // namespace
 
-GeneratorImpl::GeneratorImpl(ast::Module* module) : module_(module) {}
+GeneratorImpl::GeneratorImpl(Context* ctx, ast::Module* module)
+    : TextGenerator(ctx), module_(module) {}
 
 GeneratorImpl::~GeneratorImpl() = default;
 
diff --git a/src/writer/msl/generator_impl.h b/src/writer/msl/generator_impl.h
index 5fabad8..0c866af 100644
--- a/src/writer/msl/generator_impl.h
+++ b/src/writer/msl/generator_impl.h
@@ -37,8 +37,9 @@
 class GeneratorImpl : public TextGenerator {
  public:
   /// Constructor
+  /// @param ctx the context, must be non-null
   /// @param module the module to generate
-  explicit GeneratorImpl(ast::Module* module);
+  GeneratorImpl(Context* ctx, ast::Module* module);
   ~GeneratorImpl();
 
   /// @returns true on successful generation; false otherwise
@@ -245,7 +246,7 @@
   /// @returns the string name of the builtin or blank on error
   std::string builtin_to_attribute(ast::Builtin builtin) const;
 
-  /// @returns the namer for testing
+  /// @returns the namer for testing purposes
   Namer* namer_for_testing() { return &namer_; }
 
  private:
diff --git a/src/writer/msl/generator_impl_alias_type_test.cc b/src/writer/msl/generator_impl_alias_type_test.cc
index 0525e0a..25aa4d3 100644
--- a/src/writer/msl/generator_impl_alias_type_test.cc
+++ b/src/writer/msl/generator_impl_alias_type_test.cc
@@ -22,22 +22,21 @@
 #include "src/ast/type/i32_type.h"
 #include "src/ast/type/struct_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitConstructedType_F32) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("a", &f32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(typedef float a;
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(typedef float a;
 )");
 }
 
@@ -45,10 +44,8 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias("float", &f32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(typedef float float_tint_0;
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(typedef float float_tint_0;
 )");
 }
 
@@ -71,10 +68,8 @@
 
   ast::type::StructType s("a", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructedType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct a {
+  ASSERT_TRUE(gen.EmitConstructedType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct a {
   float a;
   int b;
 };
@@ -101,10 +96,8 @@
   ast::type::StructType s("b", std::move(str));
   ast::type::AliasType alias("a", &s);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(typedef b a;
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(typedef b a;
 )");
 }
 
diff --git a/src/writer/msl/generator_impl_array_accessor_test.cc b/src/writer/msl/generator_impl_array_accessor_test.cc
index bdcfa83..88ef333 100644
--- a/src/writer/msl/generator_impl_array_accessor_test.cc
+++ b/src/writer/msl/generator_impl_array_accessor_test.cc
@@ -22,13 +22,14 @@
 #include "src/ast/sint_literal.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
   ast::type::I32Type i32;
@@ -38,10 +39,8 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "ary[5]");
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "ary[5]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
@@ -50,10 +49,8 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitArrayAccessor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "ary[idx]");
+  ASSERT_TRUE(gen.EmitArrayAccessor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "ary[idx]");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_assign_test.cc b/src/writer/msl/generator_impl_assign_test.cc
index db1426b..33c8844 100644
--- a/src/writer/msl/generator_impl_assign_test.cc
+++ b/src/writer/msl/generator_impl_assign_test.cc
@@ -20,25 +20,24 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Assign) {
   auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
   auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&assign)) << g.error();
-  EXPECT_EQ(g.result(), "  lhs = rhs;\n");
+  ASSERT_TRUE(gen.EmitStatement(&assign)) << gen.error();
+  EXPECT_EQ(gen.result(), "  lhs = rhs;\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_binary_test.cc b/src/writer/msl/generator_impl_binary_test.cc
index fb9329f..bd39002 100644
--- a/src/writer/msl/generator_impl_binary_test.cc
+++ b/src/writer/msl/generator_impl_binary_test.cc
@@ -19,6 +19,7 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -33,7 +34,7 @@
   out << data.op;
   return out;
 }
-using MslBinaryTest = testing::TestWithParam<BinaryData>;
+using MslBinaryTest = TestParamHelper<BinaryData>;
 TEST_P(MslBinaryTest, Emit) {
   auto params = GetParam();
 
@@ -42,10 +43,8 @@
 
   ast::BinaryExpression expr(params.op, std::move(left), std::move(right));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), params.result);
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
diff --git a/src/writer/msl/generator_impl_bitcast_test.cc b/src/writer/msl/generator_impl_bitcast_test.cc
index 94474d7..b51dc4d 100644
--- a/src/writer/msl/generator_impl_bitcast_test.cc
+++ b/src/writer/msl/generator_impl_bitcast_test.cc
@@ -20,23 +20,22 @@
 #include "src/ast/module.h"
 #include "src/ast/type/f32_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
   ast::type::F32Type f32;
   auto id = std::make_unique<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&f32, std::move(id));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&bitcast)) << g.error();
-  EXPECT_EQ(g.result(), "as_type<float>(id)");
+  ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();
+  EXPECT_EQ(gen.result(), "as_type<float>(id)");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_block_test.cc b/src/writer/msl/generator_impl_block_test.cc
index f901c4b..8bc146a 100644
--- a/src/writer/msl/generator_impl_block_test.cc
+++ b/src/writer/msl/generator_impl_block_test.cc
@@ -18,24 +18,23 @@
 #include "src/ast/block_statement.h"
 #include "src/ast/discard_statement.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Block) {
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&b)) << g.error();
-  EXPECT_EQ(g.result(), R"(  {
+  ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
     discard_fragment();
   }
 )");
@@ -45,12 +44,10 @@
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitBlock(&b)) << g.error();
-  EXPECT_EQ(g.result(), R"({
+  ASSERT_TRUE(gen.EmitBlock(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"({
     discard_fragment();
   })");
 }
diff --git a/src/writer/msl/generator_impl_break_test.cc b/src/writer/msl/generator_impl_break_test.cc
index 941faa8..daf276c 100644
--- a/src/writer/msl/generator_impl_break_test.cc
+++ b/src/writer/msl/generator_impl_break_test.cc
@@ -19,23 +19,22 @@
 #include "src/ast/break_statement.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Break) {
   ast::BreakStatement b;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&b)) << g.error();
-  EXPECT_EQ(g.result(), "  break;\n");
+  ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), "  break;\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_call_test.cc b/src/writer/msl/generator_impl_call_test.cc
index ef6bb6b..5254542 100644
--- a/src/writer/msl/generator_impl_call_test.cc
+++ b/src/writer/msl/generator_impl_call_test.cc
@@ -22,13 +22,14 @@
 #include "src/ast/module.h"
 #include "src/ast/type/void_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
   ast::type::VoidType void_type;
@@ -38,13 +39,10 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
+  mod.AddFunction(std::move(func));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
-
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "my_func()");
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "my_func()");
 }
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
@@ -58,13 +56,10 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
+  mod.AddFunction(std::move(func));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
-
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "my_func(param1, param2)");
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "my_func(param1, param2)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
@@ -79,14 +74,11 @@
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
+  mod.AddFunction(std::move(func));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
-
-  GeneratorImpl g(&m);
-  g.increment_indent();
-  ASSERT_TRUE(g.EmitStatement(&call)) << g.error();
-  EXPECT_EQ(g.result(), "  my_func(param1, param2);\n");
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitStatement(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "  my_func(param1, param2);\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_case_test.cc b/src/writer/msl/generator_impl_case_test.cc
index cd43294..a35e897 100644
--- a/src/writer/msl/generator_impl_case_test.cc
+++ b/src/writer/msl/generator_impl_case_test.cc
@@ -23,13 +23,14 @@
 #include "src/ast/sint_literal.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Case) {
   ast::type::I32Type i32;
@@ -41,12 +42,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
     break;
   }
 )");
@@ -59,12 +58,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::make_unique<ast::BlockStatement>());
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
     break;
   }
 )");
@@ -80,12 +77,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
     /* fallthrough */
   }
 )");
@@ -102,12 +97,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 6));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5:
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5:
   case 6: {
     break;
   }
@@ -121,12 +114,10 @@
   body->append(std::make_unique<ast::BreakStatement>());
   c.set_body(std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  default: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  default: {
     break;
   }
 )");
diff --git a/src/writer/msl/generator_impl_cast_test.cc b/src/writer/msl/generator_impl_cast_test.cc
index aea7840..cc24552 100644
--- a/src/writer/msl/generator_impl_cast_test.cc
+++ b/src/writer/msl/generator_impl_cast_test.cc
@@ -21,13 +21,14 @@
 #include "src/ast/type/vector_type.h"
 #include "src/ast/type_constructor_expression.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Scalar) {
   ast::type::F32Type f32;
@@ -37,10 +38,8 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&cast)) << g.error();
-  EXPECT_EQ(g.result(), "float(id)");
+  ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
+  EXPECT_EQ(gen.result(), "float(id)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Vector) {
@@ -52,10 +51,8 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&cast)) << g.error();
-  EXPECT_EQ(g.result(), "float3(id)");
+  ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
+  EXPECT_EQ(gen.result(), "float3(id)");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_constructor_test.cc b/src/writer/msl/generator_impl_constructor_test.cc
index 38132e1..705cd52 100644
--- a/src/writer/msl/generator_impl_constructor_test.cc
+++ b/src/writer/msl/generator_impl_constructor_test.cc
@@ -28,23 +28,22 @@
 #include "src/ast/type_constructor_expression.h"
 #include "src/ast/uint_literal.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
   ast::type::BoolType bool_type;
   auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "false");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "false");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
@@ -52,10 +51,8 @@
   auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "-12345");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "-12345");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
@@ -63,10 +60,8 @@
   auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "56779u");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "56779u");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
@@ -76,10 +71,8 @@
       &f32, static_cast<float>((1 << 30) - 4));
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "1.07374182e+09f");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "1.07374182e+09f");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
@@ -92,10 +85,8 @@
 
   ast::TypeConstructorExpression expr(&f32, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "float(-1.20000004e-05f)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "float(-1.20000004e-05f)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
@@ -108,10 +99,8 @@
 
   ast::TypeConstructorExpression expr(&b, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "bool(true)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "bool(true)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
@@ -124,10 +113,8 @@
 
   ast::TypeConstructorExpression expr(&i32, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "int(-12345)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "int(-12345)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Uint) {
@@ -140,10 +127,8 @@
 
   ast::TypeConstructorExpression expr(&u32, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "uint(12345u)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "uint(12345u)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec) {
@@ -163,10 +148,8 @@
 
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "float3(1.00000000f, 2.00000000f, 3.00000000f)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "float3(1.00000000f, 2.00000000f, 3.00000000f)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec_Empty) {
@@ -176,10 +159,8 @@
   ast::ExpressionList values;
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "float3(0.0f)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "float3(0.0f)");
 }
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Mat) {
@@ -213,15 +194,12 @@
   }
 
   ast::TypeConstructorExpression expr(&mat, std::move(mat_values));
-
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
 
   // A matrix of type T with n columns and m rows can also be constructed from
   // n vectors of type T with m components.
   EXPECT_EQ(
-      g.result(),
+      gen.result(),
       std::string("float2x3(float3(1.00000000f, 2.00000000f, 3.00000000f), ") +
           "float3(3.00000000f, 4.00000000f, 5.00000000f))");
 }
@@ -254,14 +232,12 @@
   }
 
   ast::TypeConstructorExpression expr(&ary, std::move(ary_values));
-
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("{") +
-                            "float3(1.00000000f, 2.00000000f, 3.00000000f), " +
-                            "float3(4.00000000f, 5.00000000f, 6.00000000f), " +
-                            "float3(7.00000000f, 8.00000000f, 9.00000000f)}");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(),
+            std::string("{") +
+                "float3(1.00000000f, 2.00000000f, 3.00000000f), " +
+                "float3(4.00000000f, 5.00000000f, 6.00000000f), " +
+                "float3(7.00000000f, 8.00000000f, 9.00000000f)}");
 }
 
 // TODO(dsinclair): Add struct constructor test.
diff --git a/src/writer/msl/generator_impl_continue_test.cc b/src/writer/msl/generator_impl_continue_test.cc
index 389329a..95220bc 100644
--- a/src/writer/msl/generator_impl_continue_test.cc
+++ b/src/writer/msl/generator_impl_continue_test.cc
@@ -19,23 +19,22 @@
 #include "src/ast/continue_statement.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Continue) {
   ast::ContinueStatement c;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&c)) << g.error();
-  EXPECT_EQ(g.result(), "  continue;\n");
+  ASSERT_TRUE(gen.EmitStatement(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), "  continue;\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_discard_test.cc b/src/writer/msl/generator_impl_discard_test.cc
index 5d3ab30..182dc10 100644
--- a/src/writer/msl/generator_impl_discard_test.cc
+++ b/src/writer/msl/generator_impl_discard_test.cc
@@ -16,23 +16,22 @@
 #include "src/ast/discard_statement.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Discard) {
   ast::DiscardStatement stmt;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  discard_fragment();\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  discard_fragment();\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_function_entry_point_data_test.cc b/src/writer/msl/generator_impl_function_entry_point_data_test.cc
index 778da93..910e57c 100644
--- a/src/writer/msl/generator_impl_function_entry_point_data_test.cc
+++ b/src/writer/msl/generator_impl_function_entry_point_data_test.cc
@@ -31,13 +31,14 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Input) {
   // [[location 0]] var<in> foo : f32;
@@ -63,9 +64,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -92,9 +90,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct vtx_main_in {
+  ASSERT_TRUE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct vtx_main_in {
   float foo [[attribute(0)]];
   int bar [[attribute(1)]];
 };
@@ -126,9 +123,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -155,9 +149,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct vtx_main_out {
+  ASSERT_TRUE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct vtx_main_out {
   float foo [[user(locn0)]];
   int bar [[user(locn1)]];
 };
@@ -189,9 +182,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -217,9 +207,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct main_in {
+  ASSERT_TRUE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct main_in {
   float foo [[user(locn0)]];
   int bar [[user(locn1)]];
 };
@@ -251,9 +240,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -279,9 +265,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct main_out {
+  ASSERT_TRUE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct main_out {
   float foo [[color(0)]];
   int bar [[color(1)]];
 };
@@ -310,9 +295,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -338,9 +320,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_FALSE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.error(), R"(invalid location variable for pipeline stage)");
+  ASSERT_FALSE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.error(), R"(invalid location variable for pipeline stage)");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Output) {
@@ -364,9 +345,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -392,9 +370,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_FALSE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.error(), R"(invalid location variable for pipeline stage)");
+  ASSERT_FALSE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.error(), R"(invalid location variable for pipeline stage)");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Builtins) {
@@ -428,9 +405,6 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
   td.RegisterVariableForTesting(depth_var.get());
 
@@ -456,9 +430,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitEntryPointData(func_ptr)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct main_out {
+  ASSERT_TRUE(gen.EmitEntryPointData(func_ptr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct main_out {
   float depth [[depth(any)]];
 };
 
diff --git a/src/writer/msl/generator_impl_function_test.cc b/src/writer/msl/generator_impl_function_test.cc
index a5d871b..08d61d6 100644
--- a/src/writer/msl/generator_impl_function_test.cc
+++ b/src/writer/msl/generator_impl_function_test.cc
@@ -48,13 +48,14 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Function) {
   ast::type::VoidType void_type;
@@ -66,14 +67,11 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  GeneratorImpl g(&m);
-  g.increment_indent();
-
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
   void my_func() {
     return;
@@ -92,14 +90,11 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  GeneratorImpl g(&m);
-  g.increment_indent();
-
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
   void main_tint_0() {
     return;
@@ -126,14 +121,11 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
+  gen.increment_indent();
 
-  GeneratorImpl g(&m);
-  g.increment_indent();
-
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
   void my_func(float a, int b) {
     return;
@@ -158,9 +150,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
 
@@ -184,9 +173,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct frag_main_in {
   float foo [[user(locn0)]];
@@ -227,9 +215,6 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
   td.RegisterVariableForTesting(depth_var.get());
 
@@ -255,9 +240,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct frag_main_out {
   float depth [[depth(any)]];
@@ -286,9 +270,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
 
   mod.AddGlobalVariable(std::move(coord_var));
@@ -314,9 +295,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 fragment void frag_main(constant float4& coord [[buffer(0)]]) {
   float v = coord.x;
@@ -331,7 +311,6 @@
   ast::type::VoidType void_type;
   ast::type::F32Type f32;
   ast::type::I32Type i32;
-  ast::Module mod;
 
   ast::StructMemberList members;
   ast::StructMemberDecorationList a_deco;
@@ -363,8 +342,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
 
   mod.AddGlobalVariable(std::move(coord_var));
@@ -389,10 +366,8 @@
   mod.AddFunction(std::move(func));
 
   ASSERT_TRUE(td.Determine()) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct Data {
   int a;
@@ -412,7 +387,6 @@
   ast::type::VoidType void_type;
   ast::type::F32Type f32;
   ast::type::I32Type i32;
-  ast::Module mod;
 
   ast::StructMemberList members;
   ast::StructMemberDecorationList a_deco;
@@ -444,8 +418,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
 
   mod.AddGlobalVariable(std::move(coord_var));
@@ -471,9 +443,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct Data {
   int a;
@@ -511,9 +482,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
   val_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(foo_var.get());
   td.RegisterVariableForTesting(bar_var.get());
   td.RegisterVariableForTesting(val_var.get());
@@ -563,9 +531,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct ep_1_in {
   float foo [[user(locn0)]];
@@ -606,9 +573,6 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(depth_var.get());
 
   mod.AddGlobalVariable(std::move(depth_var));
@@ -648,9 +612,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct ep_1_out {
   float depth [[depth(any)]];
@@ -692,9 +655,6 @@
       ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
   td.RegisterVariableForTesting(depth_var.get());
 
@@ -740,10 +700,8 @@
   mod.AddFunction(std::move(func_1));
 
   ASSERT_TRUE(td.Determine()) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct ep_1_out {
   float depth [[depth(any)]];
@@ -778,9 +736,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
 
   mod.AddGlobalVariable(std::move(coord_var));
@@ -823,10 +778,8 @@
   mod.AddFunction(std::move(func));
 
   ASSERT_TRUE(td.Determine()) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 float sub_func(constant float4& coord, float param) {
   return coord.x;
@@ -845,7 +798,6 @@
   ast::type::VoidType void_type;
   ast::type::F32Type f32;
   ast::type::I32Type i32;
-  ast::Module mod;
 
   ast::StructMemberList members;
   ast::StructMemberDecorationList a_deco;
@@ -877,10 +829,7 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
-
   mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
@@ -922,9 +871,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct Data {
   int a;
@@ -948,7 +896,6 @@
   ast::type::VoidType void_type;
   ast::type::F32Type f32;
   ast::type::I32Type i32;
-  ast::Module mod;
 
   ast::StructMemberList members;
   ast::StructMemberDecorationList a_deco;
@@ -980,10 +927,7 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(1, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(coord_var.get());
-
   mod.AddGlobalVariable(std::move(coord_var));
 
   ast::VariableList params;
@@ -1025,9 +969,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct Data {
   int a;
@@ -1058,9 +1001,6 @@
   decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(bar_var.get());
   mod.AddGlobalVariable(std::move(bar_var));
 
@@ -1094,10 +1034,8 @@
   mod.AddFunction(std::move(func_1));
 
   ASSERT_TRUE(td.Determine()) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct ep_1_out {
   float bar [[color(1)]];
@@ -1124,12 +1062,10 @@
   func->add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kCompute, Source{}));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 kernel void main_tint_0() {
 }
@@ -1153,14 +1089,12 @@
   body->append(std::make_unique<ast::ReturnStatement>());
   func->set_body(std::move(body));
 
-  ast::Module m;
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
   void my_func(float a[5]) {
     return;
@@ -1215,10 +1149,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(0, Source{}));
   data_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   mod.AddConstructedType(&s);
 
   td.RegisterVariableForTesting(data_var.get());
@@ -1268,9 +1198,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 struct Data {
   float d;
diff --git a/src/writer/msl/generator_impl_identifier_test.cc b/src/writer/msl/generator_impl_identifier_test.cc
index 2e07db5..d5be38b 100644
--- a/src/writer/msl/generator_impl_identifier_test.cc
+++ b/src/writer/msl/generator_impl_identifier_test.cc
@@ -16,30 +16,27 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) {
   ast::IdentifierExpression i("foo");
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "foo");
+  ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), "foo");
 }
 
 TEST_F(MslGeneratorImplTest, EmitIdentifierExpression_Single_WithCollision) {
   ast::IdentifierExpression i("virtual");
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "virtual_tint_0");
+  ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), "virtual_tint_0");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_if_test.cc b/src/writer/msl/generator_impl_if_test.cc
index 8686b14..04dfc7e 100644
--- a/src/writer/msl/generator_impl_if_test.cc
+++ b/src/writer/msl/generator_impl_if_test.cc
@@ -19,13 +19,14 @@
 #include "src/ast/module.h"
 #include "src/ast/return_statement.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_If) {
   auto cond = std::make_unique<ast::IdentifierExpression>("cond");
@@ -34,12 +35,10 @@
 
   ast::IfStatement i(std::move(cond), std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     return;
   }
 )");
@@ -61,12 +60,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     return;
   } else if (else_cond) {
     return;
@@ -88,12 +85,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     return;
   } else {
     return;
@@ -122,12 +117,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     return;
   } else if (else_cond) {
     return;
diff --git a/src/writer/msl/generator_impl_import_test.cc b/src/writer/msl/generator_impl_import_test.cc
index 1e56fc8..8ecb356 100644
--- a/src/writer/msl/generator_impl_import_test.cc
+++ b/src/writer/msl/generator_impl_import_test.cc
@@ -31,13 +31,14 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 struct MslImportData {
   const char* name;
@@ -47,7 +48,7 @@
   out << data.name;
   return out;
 }
-using MslImportData_SingleParamTest = testing::TestWithParam<MslImportData>;
+using MslImportData_SingleParamTest = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_SingleParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -62,15 +63,10 @@
 
   ast::CallExpression call(std::move(ident), std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   // The call type determination will set the intrinsic data for the ident
   ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_EQ(g.generate_builtin_name(ident_ptr),
+  ASSERT_EQ(gen.generate_builtin_name(ident_ptr),
             std::string("metal::") + param.msl_name);
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
@@ -109,18 +105,13 @@
   ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("abs"),
                            std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), R"(metal::abs(1))");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(metal::abs(1))");
 }
 
-using MslImportData_DualParamTest = testing::TestWithParam<MslImportData>;
+using MslImportData_DualParamTest = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_DualParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -136,16 +127,10 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
-                            "(1.00000000f, 2.00000000f)");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string("metal::") + param.msl_name +
+                              "(1.00000000f, 2.00000000f)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_DualParamTest,
@@ -157,8 +142,7 @@
                                          MslImportData{"reflect", "reflect"},
                                          MslImportData{"step", "step"}));
 
-using MslImportData_DualParam_VectorTest =
-    testing::TestWithParam<MslImportData>;
+using MslImportData_DualParam_VectorTest = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
   auto param = GetParam();
 
@@ -190,23 +174,17 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
-                            "(float3(1.00000000f, 2.00000000f, 3.00000000f), "
-                            "float3(4.00000000f, 5.00000000f, 6.00000000f))");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string("metal::") + param.msl_name +
+                              "(float3(1.00000000f, 2.00000000f, 3.00000000f), "
+                              "float3(4.00000000f, 5.00000000f, 6.00000000f))");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_DualParam_VectorTest,
                          testing::Values(MslImportData{"cross", "cross"}));
 
-using MslImportData_DualParam_Int_Test = testing::TestWithParam<MslImportData>;
+using MslImportData_DualParam_Int_Test = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_DualParam_Int_Test, IntScalar) {
   auto param = GetParam();
 
@@ -222,22 +200,16 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name + "(1, 2)");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string("metal::") + param.msl_name + "(1, 2)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_DualParam_Int_Test,
                          testing::Values(MslImportData{"max", "max"},
                                          MslImportData{"min", "min"}));
 
-using MslImportData_TripleParamTest = testing::TestWithParam<MslImportData>;
+using MslImportData_TripleParamTest = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_TripleParamTest, FloatScalar) {
   auto param = GetParam();
 
@@ -255,16 +227,10 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
-                            "(1.00000000f, 2.00000000f, 3.00000000f)");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string("metal::") + param.msl_name +
+                              "(1.00000000f, 2.00000000f, 3.00000000f)");
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
@@ -275,8 +241,7 @@
                     MslImportData{"clamp", "clamp"},
                     MslImportData{"smoothStep", "smoothstep"}));
 
-using MslImportData_TripleParam_Int_Test =
-    testing::TestWithParam<MslImportData>;
+using MslImportData_TripleParam_Int_Test = TestParamHelper<MslImportData>;
 TEST_P(MslImportData_TripleParam_Int_Test, IntScalar) {
   auto param = GetParam();
 
@@ -294,15 +259,10 @@
       std::make_unique<ast::IdentifierExpression>(param.name),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name + "(1, 2, 3)");
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(),
+            std::string("metal::") + param.msl_name + "(1, 2, 3)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_TripleParam_Int_Test,
@@ -323,18 +283,13 @@
       std::make_unique<ast::IdentifierExpression>("determinant"),
       std::move(params));
 
-  Context ctx;
-  ast::Module mod;
   mod.AddGlobalVariable(std::move(var));
 
-  TypeDeterminer td(&ctx, &mod);
   // Register the global
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("metal::determinant(var)"));
+  ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string("metal::determinant(var)"));
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_intrinsic_test.cc b/src/writer/msl/generator_impl_intrinsic_test.cc
index 4f02220..eb9121d 100644
--- a/src/writer/msl/generator_impl_intrinsic_test.cc
+++ b/src/writer/msl/generator_impl_intrinsic_test.cc
@@ -21,13 +21,14 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 struct IntrinsicData {
   ast::Intrinsic intrinsic;
@@ -37,13 +38,10 @@
   out << data.msl_name;
   return out;
 }
-using MslIntrinsicTest = testing::TestWithParam<IntrinsicData>;
+using MslIntrinsicTest = TestParamHelper<IntrinsicData>;
 TEST_P(MslIntrinsicTest, Emit) {
   auto param = GetParam();
-
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(g.generate_intrinsic_name(param.intrinsic), param.msl_name);
+  EXPECT_EQ(gen.generate_intrinsic_name(param.intrinsic), param.msl_name);
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
@@ -86,29 +84,22 @@
       std::make_unique<ast::IdentifierExpression>("outer_product"),
       std::move(params));
 
-  Context ctx;
-  ast::Module m;
-  TypeDeterminer td(&ctx, &m);
   td.RegisterVariableForTesting(a.get());
   td.RegisterVariableForTesting(b.get());
 
-  m.AddGlobalVariable(std::move(a));
-  m.AddGlobalVariable(std::move(b));
+  mod.AddGlobalVariable(std::move(a));
+  mod.AddGlobalVariable(std::move(b));
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
-  GeneratorImpl g(&m);
-
-  g.increment_indent();
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "  float3x2(a * b[0], a * b[1], a * b[2])");
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float3x2(a * b[0], a * b[1], a * b[2])");
 }
 
 TEST_F(MslGeneratorImplTest, Intrinsic_Bad_Name) {
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(g.generate_intrinsic_name(ast::Intrinsic::kNone), "");
+  EXPECT_EQ(gen.generate_intrinsic_name(ast::Intrinsic::kNone), "");
 }
 
 TEST_F(MslGeneratorImplTest, Intrinsic_Call) {
@@ -122,10 +113,6 @@
   ast::CallExpression call(std::make_unique<ast::IdentifierExpression>("dot"),
                            std::move(params));
 
-  Context ctx;
-  ast::Module m;
-  TypeDeterminer td(&ctx, &m);
-
   ast::Variable v1("param1", ast::StorageClass::kFunction, &vec);
   ast::Variable v2("param2", ast::StorageClass::kFunction, &vec);
 
@@ -134,10 +121,9 @@
 
   ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
-  GeneratorImpl g(&m);
-  g.increment_indent();
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "  dot(param1, param2)");
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "  dot(param1, param2)");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_loop_test.cc b/src/writer/msl/generator_impl_loop_test.cc
index c11efdc..c105ccd 100644
--- a/src/writer/msl/generator_impl_loop_test.cc
+++ b/src/writer/msl/generator_impl_loop_test.cc
@@ -26,13 +26,14 @@
 #include "src/ast/variable.h"
 #include "src/ast/variable_decl_statement.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Loop) {
   auto body = std::make_unique<ast::BlockStatement>();
@@ -40,12 +41,10 @@
 
   ast::LoopStatement l(std::move(body), {});
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&l)) << g.error();
-  EXPECT_EQ(g.result(), R"(  for(;;) {
+  ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  for(;;) {
     discard_fragment();
   }
 )");
@@ -60,12 +59,10 @@
 
   ast::LoopStatement l(std::move(body), std::move(continuing));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&l)) << g.error();
-  EXPECT_EQ(g.result(), R"(  {
+  ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
     bool tint_msl_is_first_1 = true;
     for(;;) {
       if (!tint_msl_is_first_1) {
@@ -103,12 +100,10 @@
 
   ast::LoopStatement outer(std::move(body), std::move(continuing));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&outer)) << g.error();
-  EXPECT_EQ(g.result(), R"(  {
+  ASSERT_TRUE(gen.EmitStatement(&outer)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
     bool tint_msl_is_first_1 = true;
     for(;;) {
       if (!tint_msl_is_first_1) {
@@ -174,14 +169,12 @@
   continuing->append(std::make_unique<ast::AssignmentStatement>(
       std::move(lhs), std::move(rhs)));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
   ast::LoopStatement outer(std::move(body), std::move(continuing));
 
-  ASSERT_TRUE(g.EmitStatement(&outer)) << g.error();
-  EXPECT_EQ(g.result(), R"(  {
+  ASSERT_TRUE(gen.EmitStatement(&outer)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
     bool tint_msl_is_first_1 = true;
     float lhs;
     float other;
diff --git a/src/writer/msl/generator_impl_member_accessor_test.cc b/src/writer/msl/generator_impl_member_accessor_test.cc
index 9567511..ef81eea 100644
--- a/src/writer/msl/generator_impl_member_accessor_test.cc
+++ b/src/writer/msl/generator_impl_member_accessor_test.cc
@@ -19,13 +19,14 @@
 #include "src/ast/member_accessor_expression.h"
 #include "src/ast/module.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
   auto str = std::make_unique<ast::IdentifierExpression>("str");
@@ -33,10 +34,8 @@
 
   ast::MemberAccessorExpression expr(std::move(str), std::move(mem));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "str.mem");
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "str.mem");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_module_constant_test.cc b/src/writer/msl/generator_impl_module_constant_test.cc
index 757ed56..cb4b309 100644
--- a/src/writer/msl/generator_impl_module_constant_test.cc
+++ b/src/writer/msl/generator_impl_module_constant_test.cc
@@ -26,13 +26,14 @@
 #include "src/ast/type_constructor_expression.h"
 #include "src/ast/variable.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_ModuleConstant) {
   ast::type::F32Type f32;
@@ -52,11 +53,9 @@
   var->set_constructor(
       std::make_unique<ast::TypeConstructorExpression>(&ary, std::move(exprs)));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitProgramConstVariable(var.get())) << g.error();
+  ASSERT_TRUE(gen.EmitProgramConstVariable(var.get())) << gen.error();
   EXPECT_EQ(
-      g.result(),
+      gen.result(),
       "constant float pos[3] = {1.00000000f, 2.00000000f, 3.00000000f};\n");
 }
 
@@ -73,10 +72,8 @@
   var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitProgramConstVariable(var.get())) << g.error();
-  EXPECT_EQ(g.result(), "constant float pos [[function_constant(23)]];\n");
+  ASSERT_TRUE(gen.EmitProgramConstVariable(var.get())) << gen.error();
+  EXPECT_EQ(gen.result(), "constant float pos [[function_constant(23)]];\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_return_test.cc b/src/writer/msl/generator_impl_return_test.cc
index 3d68fa2..0318614 100644
--- a/src/writer/msl/generator_impl_return_test.cc
+++ b/src/writer/msl/generator_impl_return_test.cc
@@ -20,35 +20,32 @@
 #include "src/ast/module.h"
 #include "src/ast/return_statement.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Return) {
   ast::ReturnStatement r;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&r)) << g.error();
-  EXPECT_EQ(g.result(), "  return;\n");
+  ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::ReturnStatement r(std::move(expr));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&r)) << g.error();
-  EXPECT_EQ(g.result(), "  return expr;\n");
+  ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return expr;\n");
 }
 
 }  // namespace
diff --git a/src/writer/msl/generator_impl_switch_test.cc b/src/writer/msl/generator_impl_switch_test.cc
index 60b0482..13c99e2 100644
--- a/src/writer/msl/generator_impl_switch_test.cc
+++ b/src/writer/msl/generator_impl_switch_test.cc
@@ -23,13 +23,14 @@
 #include "src/ast/switch_statement.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Switch) {
   auto def = std::make_unique<ast::CaseStatement>();
@@ -54,12 +55,10 @@
   auto cond = std::make_unique<ast::IdentifierExpression>("cond");
   ast::SwitchStatement s(std::move(cond), std::move(body));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(  switch(cond) {
+  ASSERT_TRUE(gen.EmitStatement(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  switch(cond) {
     case 5: {
       break;
     }
diff --git a/src/writer/msl/generator_impl_test.cc b/src/writer/msl/generator_impl_test.cc
index c820cc9..13f6292 100644
--- a/src/writer/msl/generator_impl_test.cc
+++ b/src/writer/msl/generator_impl_test.cc
@@ -38,28 +38,26 @@
 #include "src/ast/type/vector_type.h"
 #include "src/ast/type/void_type.h"
 #include "src/writer/msl/namer.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Generate) {
   ast::type::VoidType void_type;
-  ast::Module m;
 
   auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
                                               &void_type);
   func->add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kCompute, Source{}));
-  m.AddFunction(std::move(func));
+  mod.AddFunction(std::move(func));
 
-  GeneratorImpl g(&m);
-
-  ASSERT_TRUE(g.Generate()) << g.error();
-  EXPECT_EQ(g.result(), R"(#include <metal_stdlib>
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
 
 kernel void my_func() {
 }
@@ -68,30 +66,20 @@
 }
 
 TEST_F(MslGeneratorImplTest, InputStructName) {
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_EQ(g.generate_name("func_main_in"), "func_main_in");
+  ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 }
 
 TEST_F(MslGeneratorImplTest, InputStructName_ConflictWithExisting) {
-  ast::Module m;
-  GeneratorImpl g(&m);
-
-  // Register the struct name as existing.
-  auto* namer = g.namer_for_testing();
-  namer->NameFor("func_main_out");
-
-  ASSERT_EQ(g.generate_name("func_main_out"), "func_main_out_0");
+  gen.namer_for_testing()->NameFor("func_main_out");
+  ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_0");
 }
 
 TEST_F(MslGeneratorImplTest, NameConflictWith_InputStructName) {
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_EQ(g.generate_name("func_main_in"), "func_main_in");
+  ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 
   ast::IdentifierExpression ident("func_main_in");
-  ASSERT_TRUE(g.EmitIdentifier(&ident));
-  EXPECT_EQ(g.result(), "func_main_in_0");
+  ASSERT_TRUE(gen.EmitIdentifier(&ident));
+  EXPECT_EQ(gen.result(), "func_main_in_0");
 }
 
 struct MslBuiltinData {
@@ -102,13 +90,11 @@
   out << data.builtin;
   return out;
 }
-using MslBuiltinConversionTest = testing::TestWithParam<MslBuiltinData>;
+using MslBuiltinConversionTest = TestParamHelper<MslBuiltinData>;
 TEST_P(MslBuiltinConversionTest, Emit) {
   auto params = GetParam();
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(g.builtin_to_attribute(params.builtin),
+  EXPECT_EQ(gen.builtin_to_attribute(params.builtin),
             std::string(params.attribute_name));
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -130,54 +116,40 @@
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_alias) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("a", &f32);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u, g.calculate_alignment_size(&alias));
+  EXPECT_EQ(4u, gen.calculate_alignment_size(&alias));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_array) {
   ast::type::F32Type f32;
   ast::type::ArrayType ary(&f32, 4);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u * 4u, g.calculate_alignment_size(&ary));
+  EXPECT_EQ(4u * 4u, gen.calculate_alignment_size(&ary));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_bool) {
   ast::type::BoolType bool_type;
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(1u, g.calculate_alignment_size(&bool_type));
+  EXPECT_EQ(1u, gen.calculate_alignment_size(&bool_type));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_f32) {
   ast::type::F32Type f32;
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u, g.calculate_alignment_size(&f32));
+  EXPECT_EQ(4u, gen.calculate_alignment_size(&f32));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_i32) {
   ast::type::I32Type i32;
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u, g.calculate_alignment_size(&i32));
+  EXPECT_EQ(4u, gen.calculate_alignment_size(&i32));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_matrix) {
   ast::type::F32Type f32;
   ast::type::MatrixType mat(&f32, 3, 2);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u * 3u * 2u, g.calculate_alignment_size(&mat));
+  EXPECT_EQ(4u * 3u * 2u, gen.calculate_alignment_size(&mat));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_pointer) {
   ast::type::BoolType bool_type;
   ast::type::PointerType ptr(&bool_type, ast::StorageClass::kPrivate);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(0u, g.calculate_alignment_size(&ptr));
+  EXPECT_EQ(0u, gen.calculate_alignment_size(&ptr));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct) {
@@ -207,9 +179,7 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(132u, g.calculate_alignment_size(&s));
+  EXPECT_EQ(132u, gen.calculate_alignment_size(&s));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct_of_struct) {
@@ -260,16 +230,12 @@
 
   ast::type::StructType outer_s("Outer", std::move(outer_str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(80u, g.calculate_alignment_size(&outer_s));
+  EXPECT_EQ(80u, gen.calculate_alignment_size(&outer_s));
 }
 
 TEST_F(MslGeneratorImplTest, calculate_alignment_size_u32) {
   ast::type::U32Type u32;
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(4u, g.calculate_alignment_size(&u32));
+  EXPECT_EQ(4u, gen.calculate_alignment_size(&u32));
 }
 
 struct MslVectorSizeData {
@@ -280,15 +246,13 @@
   out << data.elements;
   return out;
 }
-using MslVectorSizeBoolTest = testing::TestWithParam<MslVectorSizeData>;
+using MslVectorSizeBoolTest = TestParamHelper<MslVectorSizeData>;
 TEST_P(MslVectorSizeBoolTest, calculate) {
   auto param = GetParam();
 
   ast::type::BoolType bool_type;
   ast::type::VectorType vec(&bool_type, param.elements);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(param.byte_size, g.calculate_alignment_size(&vec));
+  EXPECT_EQ(param.byte_size, gen.calculate_alignment_size(&vec));
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslVectorSizeBoolTest,
@@ -296,15 +260,13 @@
                                          MslVectorSizeData{3u, 4u},
                                          MslVectorSizeData{4u, 4u}));
 
-using MslVectorSizeI32Test = testing::TestWithParam<MslVectorSizeData>;
+using MslVectorSizeI32Test = TestParamHelper<MslVectorSizeData>;
 TEST_P(MslVectorSizeI32Test, calculate) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
   ast::type::VectorType vec(&i32, param.elements);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(param.byte_size, g.calculate_alignment_size(&vec));
+  EXPECT_EQ(param.byte_size, gen.calculate_alignment_size(&vec));
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslVectorSizeI32Test,
@@ -312,15 +274,13 @@
                                          MslVectorSizeData{3u, 16u},
                                          MslVectorSizeData{4u, 16u}));
 
-using MslVectorSizeU32Test = testing::TestWithParam<MslVectorSizeData>;
+using MslVectorSizeU32Test = TestParamHelper<MslVectorSizeData>;
 TEST_P(MslVectorSizeU32Test, calculate) {
   auto param = GetParam();
 
   ast::type::U32Type u32;
   ast::type::VectorType vec(&u32, param.elements);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(param.byte_size, g.calculate_alignment_size(&vec));
+  EXPECT_EQ(param.byte_size, gen.calculate_alignment_size(&vec));
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslVectorSizeU32Test,
@@ -328,15 +288,13 @@
                                          MslVectorSizeData{3u, 16u},
                                          MslVectorSizeData{4u, 16u}));
 
-using MslVectorSizeF32Test = testing::TestWithParam<MslVectorSizeData>;
+using MslVectorSizeF32Test = TestParamHelper<MslVectorSizeData>;
 TEST_P(MslVectorSizeF32Test, calculate) {
   auto param = GetParam();
 
   ast::type::F32Type f32;
   ast::type::VectorType vec(&f32, param.elements);
-  ast::Module m;
-  GeneratorImpl g(&m);
-  EXPECT_EQ(param.byte_size, g.calculate_alignment_size(&vec));
+  EXPECT_EQ(param.byte_size, gen.calculate_alignment_size(&vec));
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslVectorSizeF32Test,
diff --git a/src/writer/msl/generator_impl_type_test.cc b/src/writer/msl/generator_impl_type_test.cc
index 235378b..110a941 100644
--- a/src/writer/msl/generator_impl_type_test.cc
+++ b/src/writer/msl/generator_impl_type_test.cc
@@ -38,42 +38,37 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitType_Alias) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("alias", &f32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&alias, "")) << g.error();
-  EXPECT_EQ(g.result(), "alias");
+  ASSERT_TRUE(gen.EmitType(&alias, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "alias");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Alias_NameCollision) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("bool", &f32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&alias, "")) << g.error();
-  EXPECT_EQ(g.result(), "bool_tint_0");
+  ASSERT_TRUE(gen.EmitType(&alias, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool_tint_0");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Array) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&a, "ary")) << g.error();
-  EXPECT_EQ(g.result(), "bool ary[4]");
+  ASSERT_TRUE(gen.EmitType(&a, "ary")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool ary[4]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) {
@@ -81,10 +76,8 @@
   ast::type::ArrayType a(&b, 4);
   ast::type::ArrayType c(&a, 5);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&c, "ary")) << g.error();
-  EXPECT_EQ(g.result(), "bool ary[5][4]");
+  ASSERT_TRUE(gen.EmitType(&c, "ary")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool ary[5][4]");
 }
 
 // TODO(dsinclair): Is this possible? What order should it output in?
@@ -94,10 +87,8 @@
   ast::type::ArrayType c(&a, 5);
   ast::type::ArrayType d(&c);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&c, "ary")) << g.error();
-  EXPECT_EQ(g.result(), "bool ary[5][4][1]");
+  ASSERT_TRUE(gen.EmitType(&c, "ary")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool ary[5][4][1]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) {
@@ -106,87 +97,69 @@
   ast::type::ArrayType c(&a, 5);
   ast::type::ArrayType d(&c, 6);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&d, "ary")) << g.error();
-  EXPECT_EQ(g.result(), "bool ary[6][5][4]");
+  ASSERT_TRUE(gen.EmitType(&d, "ary")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool ary[6][5][4]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Array_NameCollision) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&a, "bool")) << g.error();
-  EXPECT_EQ(g.result(), "bool bool_tint_0[4]");
+  ASSERT_TRUE(gen.EmitType(&a, "bool")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool bool_tint_0[4]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&a, "")) << g.error();
-  EXPECT_EQ(g.result(), "bool[4]");
+  ASSERT_TRUE(gen.EmitType(&a, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool[4]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&a, "ary")) << g.error();
-  EXPECT_EQ(g.result(), "bool ary[1]");
+  ASSERT_TRUE(gen.EmitType(&a, "ary")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool ary[1]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray_NameCollision) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&a, "discard_fragment")) << g.error();
-  EXPECT_EQ(g.result(), "bool discard_fragment_tint_0[1]");
+  ASSERT_TRUE(gen.EmitType(&a, "discard_fragment")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool discard_fragment_tint_0[1]");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Bool) {
   ast::type::BoolType b;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&b, "")) << g.error();
-  EXPECT_EQ(g.result(), "bool");
+  ASSERT_TRUE(gen.EmitType(&b, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "bool");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_F32) {
   ast::type::F32Type f32;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&f32, "")) << g.error();
-  EXPECT_EQ(g.result(), "float");
+  ASSERT_TRUE(gen.EmitType(&f32, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "float");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_I32) {
   ast::type::I32Type i32;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&i32, "")) << g.error();
-  EXPECT_EQ(g.result(), "int");
+  ASSERT_TRUE(gen.EmitType(&i32, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "int");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Matrix) {
   ast::type::F32Type f32;
   ast::type::MatrixType m(&f32, 3, 2);
 
-  ast::Module mod;
-  GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitType(&m, "")) << g.error();
-  EXPECT_EQ(g.result(), "float2x3");
+  ASSERT_TRUE(gen.EmitType(&m, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "float2x3");
 }
 
 // TODO(dsinclair): How to annotate as workgroup?
@@ -194,10 +167,8 @@
   ast::type::F32Type f32;
   ast::type::PointerType p(&f32, ast::StorageClass::kWorkgroup);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&p, "")) << g.error();
-  EXPECT_EQ(g.result(), "float*");
+  ASSERT_TRUE(gen.EmitType(&p, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "float*");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Struct) {
@@ -219,10 +190,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), "S");
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "S");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
@@ -244,10 +213,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitStructType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct S {
+  ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct S {
   int a;
   float b;
 };
@@ -281,10 +248,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitStructType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct S {
+  ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct S {
   int8_t pad_0[4];
   int a;
   int8_t pad_1[24];
@@ -312,10 +277,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitStructType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct S {
+  ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct S {
   int main_tint_0;
   float float_tint_0;
 };
@@ -344,10 +307,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), R"(struct {
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct {
   int a;
   float b;
 })");
@@ -356,47 +317,37 @@
 TEST_F(MslGeneratorImplTest, EmitType_U32) {
   ast::type::U32Type u32;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&u32, "")) << g.error();
-  EXPECT_EQ(g.result(), "uint");
+  ASSERT_TRUE(gen.EmitType(&u32, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "uint");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Vector) {
   ast::type::F32Type f32;
   ast::type::VectorType v(&f32, 3);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&v, "")) << g.error();
-  EXPECT_EQ(g.result(), "float3");
+  ASSERT_TRUE(gen.EmitType(&v, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "float3");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Void) {
   ast::type::VoidType v;
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&v, "")) << g.error();
-  EXPECT_EQ(g.result(), "void");
+  ASSERT_TRUE(gen.EmitType(&v, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "void");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_Sampler) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kSampler);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&sampler, "")) << g.error();
-  EXPECT_EQ(g.result(), "sampler");
+  ASSERT_TRUE(gen.EmitType(&sampler, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "sampler");
 }
 
 TEST_F(MslGeneratorImplTest, EmitType_SamplerComparison) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kComparisonSampler);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&sampler, "")) << g.error();
-  EXPECT_EQ(g.result(), "sampler");
+  ASSERT_TRUE(gen.EmitType(&sampler, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "sampler");
 }
 
 struct MslDepthTextureData {
@@ -407,16 +358,14 @@
   out << data.dim;
   return out;
 }
-using MslDepthTexturesTest = testing::TestWithParam<MslDepthTextureData>;
+using MslDepthTexturesTest = TestParamHelper<MslDepthTextureData>;
 TEST_P(MslDepthTexturesTest, Emit) {
   auto params = GetParam();
 
   ast::type::DepthTextureType s(params.dim);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), params.result);
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
@@ -439,17 +388,15 @@
   out << data.dim;
   return out;
 }
-using MslSampledtexturesTest = testing::TestWithParam<MslTextureData>;
+using MslSampledtexturesTest = TestParamHelper<MslTextureData>;
 TEST_P(MslSampledtexturesTest, Emit) {
   auto params = GetParam();
 
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(params.dim, &f32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), params.result);
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
@@ -474,10 +421,8 @@
   ast::type::U32Type u32;
   ast::type::MultisampledTextureType s(ast::type::TextureDimension::k2d, &u32);
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), "texture2d_ms<uint, access::sample>");
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), "texture2d_ms<uint, access::sample>");
 }
 
 struct MslStorageTextureData {
@@ -489,7 +434,7 @@
   out << data.dim << (data.ro ? "ReadOnly" : "WriteOnly");
   return out;
 }
-using MslStorageTexturesTest = testing::TestWithParam<MslStorageTextureData>;
+using MslStorageTexturesTest = TestParamHelper<MslStorageTextureData>;
 TEST_P(MslStorageTexturesTest, Emit) {
   auto params = GetParam();
 
@@ -498,13 +443,9 @@
                                             : ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
 
-  Context ctx;
-  ast::Module m;
-  TypeDeterminer td(&ctx, &m);
-  GeneratorImpl g(&m);
   ASSERT_TRUE(td.DetermineStorageTextureSubtype(&s)) << td.error();
-  ASSERT_TRUE(g.EmitType(&s, "")) << g.error();
-  EXPECT_EQ(g.result(), params.result);
+  ASSERT_TRUE(gen.EmitType(&s, "")) << gen.error();
+  EXPECT_EQ(gen.result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
diff --git a/src/writer/msl/generator_impl_unary_op_test.cc b/src/writer/msl/generator_impl_unary_op_test.cc
index 46e9f26..485f7c8 100644
--- a/src/writer/msl/generator_impl_unary_op_test.cc
+++ b/src/writer/msl/generator_impl_unary_op_test.cc
@@ -20,6 +20,7 @@
 #include "src/ast/module.h"
 #include "src/ast/unary_op_expression.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -34,17 +35,15 @@
   out << data.op;
   return out;
 }
-using MslUnaryOpTest = testing::TestWithParam<UnaryOpData>;
+using MslUnaryOpTest = TestParamHelper<UnaryOpData>;
 TEST_P(MslUnaryOpTest, Emit) {
   auto params = GetParam();
 
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::UnaryOpExpression op(params.op, std::move(expr));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&op)) << g.error();
-  EXPECT_EQ(g.result(), std::string(params.name) + "(expr)");
+  ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslUnaryOpTest,
diff --git a/src/writer/msl/generator_impl_variable_decl_statement_test.cc b/src/writer/msl/generator_impl_variable_decl_statement_test.cc
index 66785f1..8592083 100644
--- a/src/writer/msl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/msl/generator_impl_variable_decl_statement_test.cc
@@ -31,13 +31,14 @@
 #include "src/ast/variable.h"
 #include "src/ast/variable_decl_statement.h"
 #include "src/writer/msl/generator_impl.h"
+#include "src/writer/msl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace msl {
 namespace {
 
-using MslGeneratorImplTest = testing::Test;
+using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
   ast::type::F32Type f32;
@@ -46,12 +47,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  float a = 0.0f;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float a = 0.0f;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
@@ -62,12 +61,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  const float a = 0.0f;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  const float a = 0.0f;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) {
@@ -79,12 +76,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  float a[5] = {0.0f};\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float a[5] = {0.0f};\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
@@ -109,12 +104,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), R"(  S a = {};
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  S a = {};
 )");
 }
 
@@ -127,12 +120,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  float2 a = 0.0f;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float2 a = 0.0f;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
@@ -143,12 +134,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  float3x2 a = 0.0f;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float3x2 a = 0.0f;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
@@ -158,12 +147,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  float a = 0.0f;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float a = 0.0f;\n");
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
@@ -176,10 +163,8 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), R"(float a = initializer;
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(float a = initializer;
 )");
 }
 
@@ -197,10 +182,8 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), R"(float3 a = float3(0.0f);
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(float3 a = float3(0.0f);
 )");
 }
 
diff --git a/src/writer/msl/test_helper.h b/src/writer/msl/test_helper.h
new file mode 100644
index 0000000..b8dda92
--- /dev/null
+++ b/src/writer/msl/test_helper.h
@@ -0,0 +1,53 @@
+// Copyright 2020 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_WRITER_MSL_TEST_HELPER_H_
+#define SRC_WRITER_MSL_TEST_HELPER_H_
+
+#include "gtest/gtest.h"
+#include "src/ast/module.h"
+#include "src/context.h"
+#include "src/type_determiner.h"
+#include "src/writer/wgsl/generator_impl.h"
+
+namespace tint {
+namespace writer {
+namespace msl {
+
+/// Helper class for testing
+template <typename T>
+class TestHelperBase : public T {
+ public:
+  TestHelperBase() : td(&ctx, &mod), gen(&ctx, &mod) {}
+  ~TestHelperBase() = default;
+
+  /// The context
+  Context ctx;
+  /// The module
+  ast::Module mod;
+  /// The type determiner
+  TypeDeterminer td;
+  /// The generator
+  GeneratorImpl gen;
+};
+using TestHelper = TestHelperBase<testing::Test>;
+
+template <typename T>
+using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
+
+}  // namespace msl
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_MSL_TEST_HELPER_H_
diff --git a/src/writer/spirv/binary_writer_test.cc b/src/writer/spirv/binary_writer_test.cc
index d589654..68bb796 100644
--- a/src/writer/spirv/binary_writer_test.cc
+++ b/src/writer/spirv/binary_writer_test.cc
@@ -19,17 +19,16 @@
 #include "gtest/gtest.h"
 #include "spirv/unified1/spirv.hpp11"
 #include "src/writer/spirv/builder.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BinaryWriterTest = testing::Test;
+using BinaryWriterTest = TestHelper;
 
 TEST_F(BinaryWriterTest, Preamble) {
-  ast::Module mod;
-  Builder b(&mod);
   BinaryWriter bw;
   bw.WriteHeader(5);
 
@@ -43,8 +42,6 @@
 }
 
 TEST_F(BinaryWriterTest, Float) {
-  ast::Module mod;
-  Builder b(&mod);
   b.push_annot(spv::Op::OpKill, {Operand::Float(2.4f)});
   BinaryWriter bw;
   bw.WriteBuilder(&b);
@@ -57,8 +54,6 @@
 }
 
 TEST_F(BinaryWriterTest, Int) {
-  ast::Module mod;
-  Builder b(&mod);
   b.push_annot(spv::Op::OpKill, {Operand::Int(2)});
   BinaryWriter bw;
   bw.WriteBuilder(&b);
@@ -69,8 +64,6 @@
 }
 
 TEST_F(BinaryWriterTest, String) {
-  ast::Module mod;
-  Builder b(&mod);
   b.push_annot(spv::Op::OpKill, {Operand::String("my_string")});
   BinaryWriter bw;
   bw.WriteBuilder(&b);
@@ -94,8 +87,6 @@
 }
 
 TEST_F(BinaryWriterTest, String_Multiple4Length) {
-  ast::Module mod;
-  Builder b(&mod);
   b.push_annot(spv::Op::OpKill, {Operand::String("mystring")});
   BinaryWriter bw;
   bw.WriteBuilder(&b);
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 9462723..845aa23 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -270,7 +270,10 @@
 
 Builder::AccessorInfo::~AccessorInfo() {}
 
-Builder::Builder(ast::Module* mod) : mod_(mod), scope_stack_({}) {}
+Builder::Builder(Context* ctx, ast::Module* mod)
+    : ctx_(ctx), mod_(mod), scope_stack_({}) {
+  assert(ctx_);
+}
 
 Builder::~Builder() = default;
 
@@ -424,7 +427,7 @@
   // the inspector and land the same change in MSL / HLSL to all roll into Dawn
   // at the same time.
   // OperandList operands = {Operand::Int(stage), Operand::Int(id),
-  //                         Operand::String(namer_.NameFor(func->name()))};
+  //                         Operand::String(ctx_.namer()->NameFor(func->name()))};
   OperandList operands = {Operand::Int(stage), Operand::Int(id),
                           Operand::String(func->name())};
 
@@ -508,8 +511,9 @@
   auto func_op = result_op();
   auto func_id = func_op.to_i();
 
-  push_debug(spv::Op::OpName, {Operand::Int(func_id),
-                               Operand::String(namer_.NameFor(func->name()))});
+  push_debug(spv::Op::OpName,
+             {Operand::Int(func_id),
+              Operand::String(ctx_->namer()->NameFor(func->name()))});
 
   auto ret_id = GenerateTypeIfNeeded(func->return_type());
   if (ret_id == 0) {
@@ -535,7 +539,7 @@
 
     push_debug(spv::Op::OpName,
                {Operand::Int(param_id),
-                Operand::String(namer_.NameFor(param->name()))});
+                Operand::String(ctx_->namer()->NameFor(param->name()))});
     params.push_back(Instruction{spv::Op::OpFunctionParameter,
                                  {Operand::Int(param_type_id), param_op}});
 
@@ -624,8 +628,9 @@
     return false;
   }
 
-  push_debug(spv::Op::OpName, {Operand::Int(var_id),
-                               Operand::String(namer_.NameFor(var->name()))});
+  push_debug(spv::Op::OpName,
+             {Operand::Int(var_id),
+              Operand::String(ctx_->namer()->NameFor(var->name()))});
 
   // TODO(dsinclair) We could detect if the constructor is fully const and emit
   // an initializer value for the variable instead of doing the OpLoad.
@@ -673,8 +678,9 @@
       error_ = "missing constructor for constant";
       return false;
     }
-    push_debug(spv::Op::OpName, {Operand::Int(init_id),
-                                 Operand::String(namer_.NameFor(var->name()))});
+    push_debug(spv::Op::OpName,
+               {Operand::Int(init_id),
+                Operand::String(ctx_->namer()->NameFor(var->name()))});
 
     scope_stack_.set_global(var->name(), init_id);
     spirv_id_to_variable_[init_id] = var;
@@ -694,8 +700,9 @@
     return false;
   }
 
-  push_debug(spv::Op::OpName, {Operand::Int(var_id),
-                               Operand::String(namer_.NameFor(var->name()))});
+  push_debug(spv::Op::OpName,
+             {Operand::Int(var_id),
+              Operand::String(ctx_->namer()->NameFor(var->name()))});
 
   auto* type = var->type()->UnwrapAll();
 
@@ -2474,7 +2481,7 @@
   if (!struct_type->name().empty()) {
     push_debug(spv::Op::OpName,
                {Operand::Int(struct_id),
-                Operand::String(namer_.NameFor(struct_type->name()))});
+                Operand::String(ctx_->namer()->NameFor(struct_type->name()))});
   }
 
   OperandList ops;
@@ -2517,7 +2524,7 @@
                                        ast::StructMember* member) {
   push_debug(spv::Op::OpMemberName,
              {Operand::Int(struct_id), Operand::Int(idx),
-              Operand::String(namer_.NameFor(member->name()))});
+              Operand::String(ctx_->namer()->NameFor(member->name()))});
 
   bool has_layout = false;
   for (const auto& deco : member->decorations()) {
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index c639050..dd0d20d 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -29,7 +29,7 @@
 #include "src/ast/type/access_control_type.h"
 #include "src/ast/type/storage_texture_type.h"
 #include "src/ast/type_constructor_expression.h"
-#include "src/namer.h"
+#include "src/context.h"
 #include "src/scope_stack.h"
 #include "src/writer/spirv/function.h"
 #include "src/writer/spirv/instruction.h"
@@ -61,8 +61,9 @@
   };
 
   /// Constructor
+  /// @param ctx the context, must be non-null
   /// @param mod the module to generate from
-  explicit Builder(ast::Module* mod);
+  Builder(Context* ctx, ast::Module* mod);
   ~Builder();
 
   /// Generates the SPIR-V instructions for the given module
@@ -469,9 +470,9 @@
     return func_name_to_id_[name];
   }
 
+  Context* ctx_ = nullptr;
   ast::Module* mod_;
   std::string error_;
-  Namer namer_;
   uint32_t next_id_ = 1;
   uint32_t current_label_id_ = 0;
   InstructionList capabilities_;
diff --git a/src/writer/spirv/builder_accessor_expression_test.cc b/src/writer/spirv/builder_accessor_expression_test.cc
index e1cf72d..4f2dde6 100644
--- a/src/writer/spirv/builder_accessor_expression_test.cc
+++ b/src/writer/spirv/builder_accessor_expression_test.cc
@@ -37,13 +37,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, ArrayAccessor) {
   ast::type::I32Type i32;
@@ -61,13 +62,9 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx_expr));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -106,14 +103,10 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx_expr));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   td.RegisterVariableForTesting(&idx);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   ASSERT_TRUE(b.GenerateFunctionVariable(&idx)) << b.error();
@@ -159,13 +152,9 @@
                           std::make_unique<ast::ScalarConstructorExpression>(
                               std::make_unique<ast::SintLiteral>(&i32, 2))));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -208,13 +197,9 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -258,13 +243,9 @@
               std::make_unique<ast::SintLiteral>(&i32, 2))),
       std::make_unique<ast::IdentifierExpression>("xy"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   EXPECT_EQ(b.GenerateAccessorExpression(&expr), 15u);
@@ -317,13 +298,9 @@
       std::make_unique<ast::IdentifierExpression>("ident"),
       std::make_unique<ast::IdentifierExpression>("b"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -382,13 +359,9 @@
           std::make_unique<ast::IdentifierExpression>("inner")),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -451,13 +424,9 @@
           std::make_unique<ast::IdentifierExpression>("inner")),
       std::make_unique<ast::IdentifierExpression>("a"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -523,13 +492,9 @@
 
   ast::AssignmentStatement expr(std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -597,14 +562,10 @@
 
   ast::AssignmentStatement expr(std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   td.RegisterVariableForTesting(&store);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   ASSERT_TRUE(b.GenerateFunctionVariable(&store)) << b.error();
@@ -644,13 +605,9 @@
       std::make_unique<ast::IdentifierExpression>("ident"),
       std::make_unique<ast::IdentifierExpression>("y"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -684,13 +641,9 @@
       std::make_unique<ast::IdentifierExpression>("ident"),
       std::make_unique<ast::IdentifierExpression>("yx"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -725,13 +678,9 @@
           std::make_unique<ast::IdentifierExpression>("yxz")),
       std::make_unique<ast::IdentifierExpression>("xz"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -767,13 +716,9 @@
           std::make_unique<ast::IdentifierExpression>("yxz")),
       std::make_unique<ast::IdentifierExpression>("x"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -810,13 +755,9 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -895,13 +836,9 @@
           std::make_unique<ast::IdentifierExpression>("baz")),
       std::make_unique<ast::IdentifierExpression>("yx"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
 
@@ -982,14 +919,10 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::UintLiteral>(&u32, 1)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error();
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   EXPECT_EQ(b.GenerateAccessorExpression(&expr), 18u) << b.error();
diff --git a/src/writer/spirv/builder_assign_test.cc b/src/writer/spirv/builder_assign_test.cc
index e7e04e4..cf0b0c4 100644
--- a/src/writer/spirv/builder_assign_test.cc
+++ b/src/writer/spirv/builder_assign_test.cc
@@ -33,13 +33,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Assign_Var) {
   ast::type::F32Type f32;
@@ -52,14 +53,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -91,14 +88,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -142,13 +135,9 @@
   ast::AssignmentStatement assign(
       std::make_unique<ast::IdentifierExpression>("var"), std::move(init));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -195,13 +184,9 @@
   ast::AssignmentStatement assign(
       std::make_unique<ast::IdentifierExpression>("var"), std::move(init));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -254,14 +239,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -306,14 +287,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -351,14 +328,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -401,14 +374,10 @@
 
   ast::AssignmentStatement assign(std::move(ident), std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
diff --git a/src/writer/spirv/builder_binary_expression_test.cc b/src/writer/spirv/builder_binary_expression_test.cc
index 6fa9f12..d7e3bbf 100644
--- a/src/writer/spirv/builder_binary_expression_test.cc
+++ b/src/writer/spirv/builder_binary_expression_test.cc
@@ -33,13 +33,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 struct BinaryData {
   ast::BinaryOp op;
@@ -50,7 +51,7 @@
   return out;
 }
 
-using BinaryArithSignedIntegerTest = testing::TestWithParam<BinaryData>;
+using BinaryArithSignedIntegerTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryArithSignedIntegerTest, Scalar) {
   auto param = GetParam();
 
@@ -63,12 +64,8 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -104,15 +101,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -136,13 +128,9 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 7u) << b.error();
@@ -177,7 +165,7 @@
                     BinaryData{ast::BinaryOp::kSubtract, "OpISub"},
                     BinaryData{ast::BinaryOp::kXor, "OpBitwiseXor"}));
 
-using BinaryArithUnsignedIntegerTest = testing::TestWithParam<BinaryData>;
+using BinaryArithUnsignedIntegerTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryArithUnsignedIntegerTest, Scalar) {
   auto param = GetParam();
 
@@ -190,12 +178,8 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -231,15 +215,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -266,7 +245,7 @@
                     BinaryData{ast::BinaryOp::kSubtract, "OpISub"},
                     BinaryData{ast::BinaryOp::kXor, "OpBitwiseXor"}));
 
-using BinaryArithFloatTest = testing::TestWithParam<BinaryData>;
+using BinaryArithFloatTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryArithFloatTest, Scalar) {
   auto param = GetParam();
 
@@ -279,12 +258,7 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -321,15 +295,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -350,7 +319,7 @@
                     BinaryData{ast::BinaryOp::kMultiply, "OpFMul"},
                     BinaryData{ast::BinaryOp::kSubtract, "OpFSub"}));
 
-using BinaryCompareUnsignedIntegerTest = testing::TestWithParam<BinaryData>;
+using BinaryCompareUnsignedIntegerTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryCompareUnsignedIntegerTest, Scalar) {
   auto param = GetParam();
 
@@ -363,12 +332,8 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -406,15 +371,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -439,7 +399,7 @@
         BinaryData{ast::BinaryOp::kLessThanEqual, "OpULessThanEqual"},
         BinaryData{ast::BinaryOp::kNotEqual, "OpINotEqual"}));
 
-using BinaryCompareSignedIntegerTest = testing::TestWithParam<BinaryData>;
+using BinaryCompareSignedIntegerTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryCompareSignedIntegerTest, Scalar) {
   auto param = GetParam();
 
@@ -452,12 +412,8 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -495,15 +451,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -528,7 +479,7 @@
         BinaryData{ast::BinaryOp::kLessThanEqual, "OpSLessThanEqual"},
         BinaryData{ast::BinaryOp::kNotEqual, "OpINotEqual"}));
 
-using BinaryCompareFloatTest = testing::TestWithParam<BinaryData>;
+using BinaryCompareFloatTest = TestParamHelper<BinaryData>;
 TEST_P(BinaryCompareFloatTest, Scalar) {
   auto param = GetParam();
 
@@ -541,12 +492,8 @@
 
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
@@ -584,15 +531,10 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(param.op, std::move(lhs), std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -634,16 +576,11 @@
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
                              std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -673,16 +610,11 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
                              std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
@@ -705,9 +637,6 @@
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
@@ -715,7 +644,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -743,9 +671,6 @@
       std::make_unique<ast::FloatLiteral>(&f32, 1.f));
   auto rhs = std::make_unique<ast::IdentifierExpression>("mat");
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
@@ -753,7 +678,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -790,9 +714,6 @@
   auto rhs =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
@@ -800,7 +721,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -839,9 +759,6 @@
 
   auto rhs = std::make_unique<ast::IdentifierExpression>("mat");
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
@@ -849,7 +766,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -878,9 +794,6 @@
   auto lhs = std::make_unique<ast::IdentifierExpression>("mat");
   auto rhs = std::make_unique<ast::IdentifierExpression>("mat");
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply, std::move(lhs),
@@ -888,7 +801,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -923,16 +835,11 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 4)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, std::move(lhs),
                              std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   b.GenerateLabel(b.next_id());
 
@@ -972,9 +879,6 @@
   auto lhs = std::make_unique<ast::IdentifierExpression>("a");
   auto rhs = std::make_unique<ast::IdentifierExpression>("b");
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(a_var.get());
   td.RegisterVariableForTesting(b_var.get());
 
@@ -983,7 +887,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   b.GenerateLabel(b.next_id());
 
@@ -1028,16 +931,11 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 4)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, std::move(lhs),
                              std::move(rhs));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   b.GenerateLabel(b.next_id());
 
@@ -1077,9 +975,6 @@
   auto lhs = std::make_unique<ast::IdentifierExpression>("a");
   auto rhs = std::make_unique<ast::IdentifierExpression>("b");
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(a_var.get());
   td.RegisterVariableForTesting(b_var.get());
 
@@ -1088,7 +983,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   b.GenerateLabel(b.next_id());
 
diff --git a/src/writer/spirv/builder_bitcast_expression_test.cc b/src/writer/spirv/builder_bitcast_expression_test.cc
index 04b6665..bf40037 100644
--- a/src/writer/spirv/builder_bitcast_expression_test.cc
+++ b/src/writer/spirv/builder_bitcast_expression_test.cc
@@ -23,13 +23,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Bitcast) {
   ast::type::U32Type u32;
@@ -39,12 +40,8 @@
       &u32, std::make_unique<ast::ScalarConstructorExpression>(
                 std::make_unique<ast::FloatLiteral>(&f32, 2.4)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateBitcastExpression(&bitcast), 1u);
 
@@ -64,12 +61,8 @@
       &f32, std::make_unique<ast::ScalarConstructorExpression>(
                 std::make_unique<ast::FloatLiteral>(&f32, 2.4)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateBitcastExpression(&bitcast), 1u);
 
diff --git a/src/writer/spirv/builder_block_test.cc b/src/writer/spirv/builder_block_test.cc
index b13ca1d..586357d 100644
--- a/src/writer/spirv/builder_block_test.cc
+++ b/src/writer/spirv/builder_block_test.cc
@@ -26,13 +26,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Block) {
   ast::type::F32Type f32;
@@ -64,12 +65,8 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::FloatLiteral>(&f32, 3.0f))));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&outer)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_FALSE(b.has_error()) << b.error();
 
diff --git a/src/writer/spirv/builder_call_test.cc b/src/writer/spirv/builder_call_test.cc
index 6a58806..34b0207 100644
--- a/src/writer/spirv/builder_call_test.cc
+++ b/src/writer/spirv/builder_call_test.cc
@@ -30,13 +30,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Expression_Call) {
   ast::type::F32Type f32;
@@ -69,14 +70,10 @@
       std::make_unique<ast::IdentifierExpression>("a_func"),
       std::move(call_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
   ASSERT_TRUE(td.DetermineFunction(&a_func)) << td.error();
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&a_func)) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
 
@@ -137,14 +134,10 @@
       std::make_unique<ast::IdentifierExpression>("a_func"),
       std::move(call_params)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
   ASSERT_TRUE(td.DetermineFunction(&a_func)) << td.error();
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&a_func)) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
 
diff --git a/src/writer/spirv/builder_constructor_expression_test.cc b/src/writer/spirv/builder_constructor_expression_test.cc
index cc3f99b..1655428 100644
--- a/src/writer/spirv/builder_constructor_expression_test.cc
+++ b/src/writer/spirv/builder_constructor_expression_test.cc
@@ -41,21 +41,20 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Constructor_Const) {
   ast::type::F32Type f32;
   auto fl = std::make_unique<ast::FloatLiteral>(&f32, 42.2f);
   ast::ScalarConstructorExpression c(std::move(fl));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &c, true), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -78,12 +77,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &t, true), 5u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -115,12 +110,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 7u);
@@ -153,12 +144,8 @@
 
   ast::TypeConstructorExpression cast(&alias, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -185,13 +172,9 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateFunctionVariable(var.get())) << b.error();
 
@@ -227,12 +210,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 7u);
@@ -268,12 +247,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &t, true), 0u);
   EXPECT_TRUE(b.has_error());
   EXPECT_EQ(b.error(), R"(constructor must be a constant expression)");
@@ -288,12 +263,8 @@
 
   ast::TypeConstructorExpression t(&bool_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 1u);
@@ -316,12 +287,8 @@
 
   ast::TypeConstructorExpression cast(&i32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -342,12 +309,8 @@
 
   ast::TypeConstructorExpression cast(&u32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -368,12 +331,8 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -397,12 +356,8 @@
 
   ast::TypeConstructorExpression cast(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 4u);
 
@@ -427,12 +382,8 @@
 
   ast::TypeConstructorExpression cast(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 4u);
 
@@ -462,12 +413,8 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -503,12 +450,8 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -541,12 +484,8 @@
 
   ast::TypeConstructorExpression cast(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 4u);
 
@@ -578,12 +517,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -621,12 +556,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -664,12 +595,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -711,12 +638,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 10u);
 
@@ -756,12 +679,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 9u);
 
@@ -800,12 +719,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 9u);
 
@@ -842,12 +757,8 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 11u);
 
@@ -884,12 +795,8 @@
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 11u);
 
@@ -928,12 +835,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 11u);
 
@@ -972,12 +875,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 11u);
 
@@ -1016,12 +915,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 11u);
 
@@ -1064,12 +959,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 13u);
 
@@ -1110,12 +1001,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 13u);
 
@@ -1156,12 +1043,8 @@
 
   ast::TypeConstructorExpression cast(&vec4, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateConstructorExpression(nullptr, &cast, true), 13u);
 
@@ -1206,12 +1089,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1257,12 +1136,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1316,12 +1191,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1363,12 +1234,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1420,12 +1287,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1487,12 +1350,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1538,12 +1397,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1601,12 +1456,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1676,12 +1527,8 @@
 
   ast::TypeConstructorExpression cast(&mat, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1712,12 +1559,8 @@
 
   ast::TypeConstructorExpression cast(&ary, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 6u);
 
@@ -1759,12 +1602,8 @@
 
   ast::TypeConstructorExpression cast(&ary, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 8u);
 
@@ -1809,12 +1648,8 @@
 
   ast::TypeConstructorExpression t(&s_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 6u);
@@ -1835,12 +1670,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&f32, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 2u);
@@ -1857,12 +1688,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&i32, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 2u);
@@ -1879,12 +1706,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&u32, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 2u);
@@ -1901,12 +1724,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&bool_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 2u);
@@ -1924,12 +1743,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 3u);
@@ -1948,12 +1763,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&mat, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 4u);
@@ -1973,12 +1784,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&ary, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 5u);
@@ -2006,12 +1813,8 @@
   ast::ExpressionList vals;
   ast::TypeConstructorExpression t(&s_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_EQ(b.GenerateExpression(&t), 3u);
@@ -2033,12 +1836,8 @@
 
   ast::TypeConstructorExpression cast(&i32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2061,12 +1860,8 @@
 
   ast::TypeConstructorExpression cast(&u32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2089,12 +1884,8 @@
 
   ast::TypeConstructorExpression cast(&i32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2117,12 +1908,8 @@
 
   ast::TypeConstructorExpression cast(&u32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2145,12 +1932,8 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2173,12 +1956,8 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateExpression(&cast), 1u);
 
@@ -2205,13 +1984,9 @@
 
   ast::TypeConstructorExpression cast(&ivec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2244,13 +2019,9 @@
 
   ast::TypeConstructorExpression cast(&ivec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2283,13 +2054,9 @@
 
   ast::TypeConstructorExpression cast(&uvec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2322,13 +2089,9 @@
 
   ast::TypeConstructorExpression cast(&uvec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2361,13 +2124,9 @@
 
   ast::TypeConstructorExpression cast(&fvec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2400,13 +2159,9 @@
 
   ast::TypeConstructorExpression cast(&fvec3, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
   EXPECT_EQ(b.GenerateExpression(&cast), 6u) << b.error();
@@ -2439,12 +2194,8 @@
       std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
   ast::TypeConstructorExpression t(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_TRUE(b.is_constructor_const(&t, true));
   EXPECT_FALSE(b.has_error());
 }
@@ -2460,10 +2211,6 @@
   params.push_back(std::make_unique<ast::IdentifierExpression>("c"));
   ast::TypeConstructorExpression t(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::Variable var_a("a", ast::StorageClass::kPrivate, &f32);
   ast::Variable var_b("b", ast::StorageClass::kPrivate, &f32);
   ast::Variable var_c("c", ast::StorageClass::kPrivate, &f32);
@@ -2473,7 +2220,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, true));
   EXPECT_TRUE(b.has_error());
   EXPECT_EQ(b.error(), "constructor must be a constant expression");
@@ -2510,12 +2256,8 @@
   ary_params.push_back(std::move(second));
   ast::TypeConstructorExpression t(&ary, std::move(ary_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_TRUE(b.is_constructor_const(&t, true));
   EXPECT_FALSE(b.has_error());
 }
@@ -2541,12 +2283,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vec_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, true));
   EXPECT_FALSE(b.has_error());
 }
@@ -2572,12 +2310,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vec_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, true));
   EXPECT_FALSE(b.has_error());
 }
@@ -2596,12 +2330,8 @@
       std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
   ast::TypeConstructorExpression t(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_TRUE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2617,10 +2347,6 @@
   params.push_back(std::make_unique<ast::IdentifierExpression>("c"));
   ast::TypeConstructorExpression t(&vec, std::move(params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::Variable var_a("a", ast::StorageClass::kPrivate, &f32);
   ast::Variable var_b("b", ast::StorageClass::kPrivate, &f32);
   ast::Variable var_c("c", ast::StorageClass::kPrivate, &f32);
@@ -2630,7 +2356,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2666,12 +2391,8 @@
   ary_params.push_back(std::move(second));
   ast::TypeConstructorExpression t(&ary, std::move(ary_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_TRUE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2697,12 +2418,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vec_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2728,12 +2445,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vec_params));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2751,12 +2464,8 @@
 
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2791,12 +2500,8 @@
 
   ast::TypeConstructorExpression t(&s_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_TRUE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
@@ -2830,10 +2535,6 @@
 
   ast::TypeConstructorExpression t(&s_type, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::Variable var_a("a", ast::StorageClass::kPrivate, &f32);
   ast::Variable var_b("b", ast::StorageClass::kPrivate, &f32);
   td.RegisterVariableForTesting(&var_a);
@@ -2841,7 +2542,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&t)) << td.error();
 
-  Builder b(&mod);
   EXPECT_FALSE(b.is_constructor_const(&t, false));
   EXPECT_FALSE(b.has_error());
 }
diff --git a/src/writer/spirv/builder_discard_test.cc b/src/writer/spirv/builder_discard_test.cc
index 596a24c..9a22335 100644
--- a/src/writer/spirv/builder_discard_test.cc
+++ b/src/writer/spirv/builder_discard_test.cc
@@ -18,19 +18,18 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Discard) {
   ast::DiscardStatement expr;
 
-  ast::Module mod;
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateStatement(&expr), 1u) << b.error();
   EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpKill
diff --git a/src/writer/spirv/builder_format_conversion_test.cc b/src/writer/spirv/builder_format_conversion_test.cc
index 8e5b17a..4de15f4 100644
--- a/src/writer/spirv/builder_format_conversion_test.cc
+++ b/src/writer/spirv/builder_format_conversion_test.cc
@@ -15,6 +15,7 @@
 #include "gtest/gtest.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -30,14 +31,11 @@
   out << data.ast_format;
   return out;
 }
-using ImageFormatConversionTest = testing::TestWithParam<TestData>;
+using ImageFormatConversionTest = TestParamHelper<TestData>;
 
 TEST_P(ImageFormatConversionTest, ImageFormatConversion) {
   auto param = GetParam();
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.convert_image_format_to_spv(param.ast_format), param.spv_format);
 
   if (param.extended_format) {
diff --git a/src/writer/spirv/builder_function_decoration_test.cc b/src/writer/spirv/builder_function_decoration_test.cc
index 1554bc2..b549526 100644
--- a/src/writer/spirv/builder_function_decoration_test.cc
+++ b/src/writer/spirv/builder_function_decoration_test.cc
@@ -30,13 +30,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, FunctionDecoration_Stage) {
   ast::type::VoidType void_type;
@@ -45,8 +46,6 @@
   func.add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kVertex, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
   EXPECT_EQ(DumpInstructions(b.entry_points()),
             R"(OpEntryPoint Vertex %3 "main"
@@ -61,7 +60,7 @@
   out << data.stage;
   return out;
 }
-using FunctionDecoration_StageTest = testing::TestWithParam<FunctionStageData>;
+using FunctionDecoration_StageTest = TestParamHelper<FunctionStageData>;
 TEST_P(FunctionDecoration_StageTest, Emit) {
   auto params = GetParam();
 
@@ -71,8 +70,6 @@
   func.add_decoration(
       std::make_unique<ast::StageDecoration>(params.stage, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
 
   auto preamble = b.entry_points();
@@ -106,8 +103,6 @@
   auto v_wg = std::make_unique<ast::Variable>(
       "my_wg", ast::StorageClass::kWorkgroup, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(v_in.get())) << b.error();
   EXPECT_TRUE(b.GenerateGlobalVariable(v_out.get())) << b.error();
   EXPECT_TRUE(b.GenerateGlobalVariable(v_wg.get())) << b.error();
@@ -166,17 +161,12 @@
   auto v_wg = std::make_unique<ast::Variable>(
       "my_wg", ast::StorageClass::kWorkgroup, &f32);
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v_in.get());
   td.RegisterVariableForTesting(v_out.get());
   td.RegisterVariableForTesting(v_wg.get());
 
   ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
 
-  Builder b(&mod);
-
   EXPECT_TRUE(b.GenerateGlobalVariable(v_in.get())) << b.error();
   EXPECT_TRUE(b.GenerateGlobalVariable(v_out.get())) << b.error();
   EXPECT_TRUE(b.GenerateGlobalVariable(v_wg.get())) << b.error();
@@ -214,8 +204,6 @@
   func.add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kFragment, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateExecutionModes(&func, 3)) << b.error();
   EXPECT_EQ(DumpInstructions(b.execution_modes()),
             R"(OpExecutionMode %3 OriginUpperLeft
@@ -229,8 +217,6 @@
   func.add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kCompute, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateExecutionModes(&func, 3)) << b.error();
   EXPECT_EQ(DumpInstructions(b.execution_modes()),
             R"(OpExecutionMode %3 LocalSize 1 1 1
@@ -246,8 +232,6 @@
   func.add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kCompute, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateExecutionModes(&func, 3)) << b.error();
   EXPECT_EQ(DumpInstructions(b.execution_modes()),
             R"(OpExecutionMode %3 LocalSize 2 4 6
@@ -265,8 +249,6 @@
   func2.add_decoration(std::make_unique<ast::StageDecoration>(
       ast::PipelineStage::kFragment, Source{}));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func1)) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func2)) << b.error();
   EXPECT_EQ(DumpBuilder(b),
diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc
index 5677d76..98380d5 100644
--- a/src/writer/spirv/builder_function_test.cc
+++ b/src/writer/spirv/builder_function_test.cc
@@ -37,22 +37,20 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Function_Empty) {
   ast::type::VoidType void_type;
   ast::Function func("a_func", {}, &void_type);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func));
-
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %3 "tint_615f66756e63"
 )");
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
@@ -87,14 +85,10 @@
       std::make_unique<ast::IdentifierExpression>("a")));
   func.set_body(std::move(body));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(func.params()[0].get());
   td.RegisterVariableForTesting(func.params()[1].get());
   EXPECT_TRUE(td.DetermineFunction(&func));
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func));
   EXPECT_EQ(DumpBuilder(b), R"(OpName %4 "tint_615f66756e63"
 OpName %5 "tint_61"
@@ -120,8 +114,6 @@
   ast::Function func("a_func", {}, &void_type);
   func.set_body(std::move(body));
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func));
   EXPECT_EQ(DumpBuilder(b), R"(OpName %3 "tint_615f66756e63"
 %2 = OpTypeVoid
@@ -137,8 +129,6 @@
   ast::type::VoidType void_type;
   ast::Function func("a_func", {}, &void_type);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func));
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
 %1 = OpTypeFunction %2
@@ -150,8 +140,6 @@
   ast::Function func1("a_func", {}, &void_type);
   ast::Function func2("b_func", {}, &void_type);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateFunction(&func1));
   ASSERT_TRUE(b.GenerateFunction(&func2));
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
@@ -204,10 +192,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(0, Source{}));
   data_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   mod.AddConstructedType(&s);
 
   td.RegisterVariableForTesting(data_var.get());
@@ -257,7 +241,6 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  Builder b(&mod);
   ASSERT_TRUE(b.Build());
   EXPECT_EQ(DumpBuilder(b), R"(OpCapability Shader
 OpMemoryModel Logical GLSL450
diff --git a/src/writer/spirv/builder_function_variable_test.cc b/src/writer/spirv/builder_function_variable_test.cc
index 985a776..b03429d 100644
--- a/src/writer/spirv/builder_function_variable_test.cc
+++ b/src/writer/spirv/builder_function_variable_test.cc
@@ -37,20 +37,19 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, FunctionVar_NoStorageClass) {
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kNone, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
@@ -81,9 +80,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -91,7 +87,6 @@
 
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -132,16 +127,12 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kFunction, &vec);
   v.set_constructor(std::move(init));
 
   td.RegisterVariableForTesting(&v);
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -189,9 +180,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -200,7 +188,6 @@
 
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
diff --git a/src/writer/spirv/builder_global_variable_test.cc b/src/writer/spirv/builder_global_variable_test.cc
index 9618580..288deed 100644
--- a/src/writer/spirv/builder_global_variable_test.cc
+++ b/src/writer/spirv/builder_global_variable_test.cc
@@ -42,20 +42,19 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, GlobalVar_NoStorageClass) {
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kNone, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -70,8 +69,6 @@
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -86,8 +83,6 @@
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kInput, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -112,16 +107,12 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
   v.set_constructor(std::move(init));
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -152,9 +143,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -162,7 +150,6 @@
   v.set_is_const(true);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -190,9 +177,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -200,7 +184,6 @@
   v.set_is_const(true);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -233,9 +216,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec3, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -243,7 +223,6 @@
   v.set_is_const(true);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -273,8 +252,6 @@
   ast::DecoratedVariable dv(std::move(v));
   dv.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&dv)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -298,8 +275,6 @@
   ast::DecoratedVariable dv(std::move(v));
   dv.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&dv)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -324,8 +299,6 @@
   ast::DecoratedVariable dv(std::move(v));
   dv.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&dv)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -350,8 +323,6 @@
   v.set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::BoolLiteral>(&bool_type, true)));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %3 "tint_766172"
 )");
@@ -374,8 +345,6 @@
       "var", ast::StorageClass::kNone, &bool_type));
   v.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -400,8 +369,6 @@
   v.set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.0)));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %3 "tint_766172"
 )");
@@ -424,8 +391,6 @@
       std::make_unique<ast::Variable>("var", ast::StorageClass::kNone, &f32));
   v.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -448,8 +413,6 @@
       std::make_unique<ast::Variable>("var", ast::StorageClass::kNone, &i32));
   v.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -472,8 +435,6 @@
       std::make_unique<ast::Variable>("var", ast::StorageClass::kNone, &u32));
   v.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
 )");
@@ -494,12 +455,9 @@
   out << data.builtin;
   return out;
 }
-using BuiltinDataTest = testing::TestWithParam<BuiltinData>;
+using BuiltinDataTest = TestParamHelper<BuiltinData>;
 TEST_P(BuiltinDataTest, Convert) {
   auto params = GetParam();
-
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.ConvertBuiltin(params.builtin), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -544,8 +502,6 @@
 
   ast::Variable var("b", ast::StorageClass::kStorageBuffer, &ac);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.annots()), R"(OpMemberDecorate %3 0 NonWritable
@@ -584,8 +540,6 @@
 
   ast::Variable var("b", ast::StorageClass::kStorageBuffer, &ac);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.annots()), R"(OpMemberDecorate %3 0 NonWritable
@@ -622,8 +576,6 @@
 
   ast::Variable var("b", ast::StorageClass::kStorageBuffer, &B);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.annots()), R"(OpMemberDecorate %3 0 NonWritable
@@ -661,8 +613,6 @@
   ast::Variable var_b("b", ast::StorageClass::kStorageBuffer, &read);
   ast::Variable var_c("c", ast::StorageClass::kStorageBuffer, &rw);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&var_b)) << b.error();
   EXPECT_TRUE(b.GenerateGlobalVariable(&var_c)) << b.error();
 
diff --git a/src/writer/spirv/builder_ident_expression_test.cc b/src/writer/spirv/builder_ident_expression_test.cc
index b110319..ee2939b 100644
--- a/src/writer/spirv/builder_ident_expression_test.cc
+++ b/src/writer/spirv/builder_ident_expression_test.cc
@@ -29,13 +29,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, IdentifierExpression_GlobalConst) {
   ast::type::F32Type f32;
@@ -52,9 +53,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -63,7 +61,6 @@
 
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -84,12 +81,8 @@
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateGlobalVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
@@ -120,9 +113,6 @@
   auto init =
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(init.get())) << td.error();
 
   ast::Variable v("var", ast::StorageClass::kOutput, &f32);
@@ -130,7 +120,6 @@
   v.set_is_const(true);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   ASSERT_FALSE(b.has_error()) << b.error();
 
@@ -150,12 +139,8 @@
   ast::type::F32Type f32;
   ast::Variable v("var", ast::StorageClass::kNone, &f32);
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&v);
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&v)) << b.error();
   EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "tint_766172"
@@ -178,10 +163,6 @@
 TEST_F(BuilderTest, IdentifierExpression_Load) {
   ast::type::I32Type i32;
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::Variable var("var", ast::StorageClass::kPrivate, &i32);
 
   td.RegisterVariableForTesting(&var);
@@ -194,7 +175,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
@@ -214,10 +194,6 @@
 TEST_F(BuilderTest, IdentifierExpression_NoLoadConst) {
   ast::type::I32Type i32;
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ast::Variable var("var", ast::StorageClass::kNone, &i32);
   var.set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 2)));
@@ -233,7 +209,6 @@
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
diff --git a/src/writer/spirv/builder_if_test.cc b/src/writer/spirv/builder_if_test.cc
index 908ac58..4432237 100644
--- a/src/writer/spirv/builder_if_test.cc
+++ b/src/writer/spirv/builder_if_test.cc
@@ -32,13 +32,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, If_Empty) {
   ast::type::BoolType bool_type;
@@ -51,12 +52,8 @@
   ast::IfStatement expr(std::move(cond),
                         std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
@@ -93,13 +90,9 @@
 
   ast::IfStatement expr(std::move(cond), std::move(body));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -156,14 +149,10 @@
   ast::IfStatement expr(std::move(cond), std::move(body));
   expr.set_else_statements(std::move(else_stmts));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -227,14 +216,10 @@
   ast::IfStatement expr(std::move(cond), std::move(body));
   expr.set_else_statements(std::move(else_stmts));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -322,14 +307,10 @@
   ast::IfStatement expr(std::move(cond), std::move(body));
   expr.set_else_statements(std::move(else_stmts));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -397,13 +378,8 @@
   ast::LoopStatement expr(std::move(loop_body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -456,13 +432,8 @@
   ast::LoopStatement expr(std::move(loop_body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -511,13 +482,8 @@
   ast::LoopStatement expr(std::move(loop_body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -570,13 +536,8 @@
   ast::LoopStatement expr(std::move(loop_body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -616,13 +577,8 @@
 
   ast::IfStatement expr(std::move(cond), std::move(if_body));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
@@ -653,13 +609,8 @@
 
   ast::IfStatement expr(std::move(cond), std::move(if_body));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
diff --git a/src/writer/spirv/builder_intrinsic_test.cc b/src/writer/spirv/builder_intrinsic_test.cc
index ee67ebd..04767d7 100644
--- a/src/writer/spirv/builder_intrinsic_test.cc
+++ b/src/writer/spirv/builder_intrinsic_test.cc
@@ -45,6 +45,7 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -66,7 +67,7 @@
   Context ctx;
   ast::Module mod;
   TypeDeterminer td{&ctx, &mod};
-  spirv::Builder b{&mod};
+  spirv::Builder b{&ctx, &mod};
 };
 
 template <typename T>
diff --git a/src/writer/spirv/builder_literal_test.cc b/src/writer/spirv/builder_literal_test.cc
index 294c6b6..de94c5f 100644
--- a/src/writer/spirv/builder_literal_test.cc
+++ b/src/writer/spirv/builder_literal_test.cc
@@ -25,19 +25,18 @@
 #include "src/ast/uint_literal.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Literal_Bool_True) {
   ast::type::BoolType bool_type;
   ast::BoolLiteral b_true(&bool_type, true);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateLiteralIfNeeded(nullptr, &b_true);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(2u, id);
@@ -51,8 +50,6 @@
   ast::type::BoolType bool_type;
   ast::BoolLiteral b_false(&bool_type, false);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateLiteralIfNeeded(nullptr, &b_false);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(2u, id);
@@ -67,8 +64,6 @@
   ast::BoolLiteral b_true(&bool_type, true);
   ast::BoolLiteral b_false(&bool_type, false);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_true), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_false), 0u);
@@ -86,8 +81,6 @@
   ast::type::I32Type i32;
   ast::SintLiteral i(&i32, -23);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(2u, id);
@@ -102,8 +95,6 @@
   ast::SintLiteral i1(&i32, -23);
   ast::SintLiteral i2(&i32, -23);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -117,8 +108,6 @@
   ast::type::U32Type u32;
   ast::UintLiteral i(&u32, 23);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(2u, id);
@@ -133,8 +122,6 @@
   ast::UintLiteral i1(&u32, 23);
   ast::UintLiteral i2(&u32, 23);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -148,8 +135,6 @@
   ast::type::F32Type f32;
   ast::FloatLiteral i(&f32, 23.245f);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(2u, id);
@@ -164,8 +149,6 @@
   ast::FloatLiteral i1(&f32, 23.245f);
   ast::FloatLiteral i2(&f32, 23.245f);
 
-  ast::Module mod;
-  Builder b(&mod);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
   ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
diff --git a/src/writer/spirv/builder_loop_test.cc b/src/writer/spirv/builder_loop_test.cc
index 8518eb2..d420e88 100644
--- a/src/writer/spirv/builder_loop_test.cc
+++ b/src/writer/spirv/builder_loop_test.cc
@@ -27,13 +27,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Loop_Empty) {
   // loop {
@@ -41,12 +42,7 @@
 
   ast::LoopStatement expr;
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -81,13 +77,9 @@
   ast::LoopStatement expr(std::move(body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -137,13 +129,9 @@
           std::make_unique<ast::SintLiteral>(&i32, 3))));
   ast::LoopStatement expr(std::move(body), std::move(continuing));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(var.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
@@ -180,12 +168,8 @@
   ast::LoopStatement expr(std::move(body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
@@ -212,12 +196,8 @@
   ast::LoopStatement expr(std::move(body),
                           std::make_unique<ast::BlockStatement>());
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
diff --git a/src/writer/spirv/builder_return_test.cc b/src/writer/spirv/builder_return_test.cc
index 3099ad1..91fe8fb 100644
--- a/src/writer/spirv/builder_return_test.cc
+++ b/src/writer/spirv/builder_return_test.cc
@@ -26,19 +26,18 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Return) {
   ast::ReturnStatement ret;
 
-  ast::Module mod;
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateReturnStatement(&ret));
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -64,12 +63,8 @@
 
   ast::ReturnStatement ret(std::move(val));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateReturnStatement(&ret));
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -93,13 +88,9 @@
   ast::ReturnStatement ret(
       std::make_unique<ast::IdentifierExpression>("param"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   EXPECT_TRUE(b.GenerateReturnStatement(&ret)) << b.error();
diff --git a/src/writer/spirv/builder_switch_test.cc b/src/writer/spirv/builder_switch_test.cc
index 7d30580..e7dfaaf 100644
--- a/src/writer/spirv/builder_switch_test.cc
+++ b/src/writer/spirv/builder_switch_test.cc
@@ -31,13 +31,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Switch_Empty) {
   ast::type::I32Type i32;
@@ -49,12 +50,8 @@
 
   ast::SwitchStatement expr(std::move(cond), ast::CaseStatementList{});
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
 
   EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
@@ -112,16 +109,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
@@ -183,16 +176,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
@@ -275,16 +264,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
@@ -376,16 +361,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
@@ -454,16 +435,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
@@ -513,16 +490,12 @@
   ast::SwitchStatement expr(std::make_unique<ast::IdentifierExpression>("a"),
                             std::move(cases));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(v.get());
   td.RegisterVariableForTesting(a.get());
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   ast::Function func("a_func", {}, &i32);
 
-  Builder b(&mod);
   ASSERT_TRUE(b.GenerateGlobalVariable(v.get())) << b.error();
   ASSERT_TRUE(b.GenerateGlobalVariable(a.get())) << b.error();
   ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
diff --git a/src/writer/spirv/builder_test.cc b/src/writer/spirv/builder_test.cc
index 4df6910..0d4a92e 100644
--- a/src/writer/spirv/builder_test.cc
+++ b/src/writer/spirv/builder_test.cc
@@ -21,17 +21,16 @@
 #include "spirv/unified1/spirv.hpp11"
 #include "src/ast/module.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, InsertsPreamble) {
-  ast::Module m;
-  Builder b(&m);
   ASSERT_TRUE(b.Build());
   EXPECT_EQ(DumpBuilder(b), R"(OpCapability Shader
 OpMemoryModel Logical GLSL450
@@ -39,9 +38,6 @@
 }
 
 TEST_F(BuilderTest, TracksIdBounds) {
-  ast::Module mod;
-  Builder b(&mod);
-
   for (size_t i = 0; i < 5; i++) {
     EXPECT_EQ(b.next_id(), i + 1);
   }
diff --git a/src/writer/spirv/builder_type_test.cc b/src/writer/spirv/builder_type_test.cc
index 2759e16..e1e8362 100644
--- a/src/writer/spirv/builder_type_test.cc
+++ b/src/writer/spirv/builder_type_test.cc
@@ -42,20 +42,19 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest_Type = testing::Test;
+using BuilderTest_Type = TestHelper;
 
 TEST_F(BuilderTest_Type, GenerateAlias) {
   ast::type::F32Type f32;
   ast::type::AliasType alias_type("my_type", &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&alias_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -70,8 +69,6 @@
   ast::type::F32Type f32;
   ast::type::AliasType alias_type("my_type", &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&alias_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
@@ -86,8 +83,6 @@
   ast::type::I32Type i32;
   ast::type::ArrayType ary(&i32);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&ary);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id);
@@ -101,8 +96,6 @@
   ast::type::I32Type i32;
   ast::type::ArrayType ary(&i32);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -116,8 +109,6 @@
   ast::type::I32Type i32;
   ast::type::ArrayType ary(&i32, 4);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&ary);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id);
@@ -138,8 +129,6 @@
   ast::type::ArrayType ary(&i32, 4);
   ary.set_decorations(std::move(decos));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&ary);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id);
@@ -158,8 +147,6 @@
   ast::type::I32Type i32;
   ast::type::ArrayType ary(&i32, 4);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -174,8 +161,6 @@
 TEST_F(BuilderTest_Type, GenerateBool) {
   ast::type::BoolType bool_type;
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&bool_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -189,8 +174,6 @@
   ast::type::I32Type i32;
   ast::type::BoolType bool_type;
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&bool_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
@@ -202,8 +185,6 @@
 TEST_F(BuilderTest_Type, GenerateF32) {
   ast::type::F32Type f32;
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&f32);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -217,8 +198,6 @@
   ast::type::I32Type i32;
   ast::type::F32Type f32;
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
@@ -230,8 +209,6 @@
 TEST_F(BuilderTest_Type, GenerateI32) {
   ast::type::I32Type i32;
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&i32);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -245,8 +222,6 @@
   ast::type::I32Type i32;
   ast::type::F32Type f32;
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2u);
@@ -259,8 +234,6 @@
   ast::type::F32Type f32;
   ast::type::MatrixType mat_type(&f32, 3, 2);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&mat_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -276,8 +249,6 @@
   ast::type::I32Type i32;
   ast::type::MatrixType mat_type(&i32, 3, 4);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&mat_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 3u);
@@ -290,8 +261,6 @@
   ast::type::I32Type i32;
   ast::type::PointerType ptr(&i32, ast::StorageClass::kOutput);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&ptr);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id);
@@ -305,8 +274,6 @@
   ast::type::I32Type i32;
   ast::type::PointerType ptr(&i32, ast::StorageClass::kOutput);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1u);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1u);
 }
@@ -315,8 +282,6 @@
   auto s = std::make_unique<ast::Struct>();
   ast::type::StructType s_type("S", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -339,8 +304,6 @@
   auto s = std::make_unique<ast::Struct>(std::move(members));
   ast::type::StructType s_type("my_struct", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -369,8 +332,6 @@
                                          std::move(members));
   ast::type::StructType s_type("my_struct", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -404,8 +365,6 @@
   auto s = std::make_unique<ast::Struct>(std::move(members));
   ast::type::StructType s_type("S", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -443,8 +402,6 @@
   auto s = std::make_unique<ast::Struct>(std::move(members));
   ast::type::StructType s_type("S", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -494,8 +451,6 @@
   auto s = std::make_unique<ast::Struct>(std::move(members));
   ast::type::StructType s_type("S", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -563,8 +518,6 @@
   auto s = std::make_unique<ast::Struct>(std::move(members));
   ast::type::StructType s_type("S", std::move(s));
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -598,8 +551,6 @@
 TEST_F(BuilderTest_Type, GenerateU32) {
   ast::type::U32Type u32;
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&u32);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -613,8 +564,6 @@
   ast::type::U32Type u32;
   ast::type::F32Type f32;
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&u32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2u);
@@ -627,8 +576,6 @@
   ast::type::F32Type f32;
   ast::type::VectorType vec_type(&f32, 3);
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&vec_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -643,8 +590,6 @@
   ast::type::I32Type i32;
   ast::type::VectorType vec_type(&i32, 3);
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&vec_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
@@ -656,8 +601,6 @@
 TEST_F(BuilderTest_Type, GenerateVoid) {
   ast::type::VoidType void_type;
 
-  ast::Module mod;
-  Builder b(&mod);
   auto id = b.GenerateTypeIfNeeded(&void_type);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(id, 1u);
@@ -671,8 +614,6 @@
   ast::type::I32Type i32;
   ast::type::VoidType void_type;
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&void_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
@@ -689,12 +630,10 @@
   out << data.ast_class;
   return out;
 }
-using PtrDataTest = testing::TestWithParam<PtrData>;
+using PtrDataTest = TestParamHelper<PtrData>;
 TEST_P(PtrDataTest, ConvertStorageClass) {
   auto params = GetParam();
 
-  ast::Module mod;
-  Builder b(&mod);
   EXPECT_EQ(b.ConvertStorageClass(params.ast_class), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -717,9 +656,6 @@
 TEST_F(BuilderTest_Type, DepthTexture_Generate_2d) {
   ast::type::DepthTextureType two_d(ast::type::TextureDimension::k2d);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   auto id_two_d = b.GenerateTypeIfNeeded(&two_d);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id_two_d);
@@ -733,9 +669,6 @@
   ast::type::DepthTextureType two_d_array(
       ast::type::TextureDimension::k2dArray);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   auto id_two_d_array = b.GenerateTypeIfNeeded(&two_d_array);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id_two_d_array);
@@ -748,9 +681,6 @@
 TEST_F(BuilderTest_Type, DepthTexture_Generate_Cube) {
   ast::type::DepthTextureType cube(ast::type::TextureDimension::kCube);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   auto id_cube = b.GenerateTypeIfNeeded(&cube);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id_cube);
@@ -764,9 +694,6 @@
   ast::type::DepthTextureType cube_array(
       ast::type::TextureDimension::kCubeArray);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   auto id_cube_array = b.GenerateTypeIfNeeded(&cube_array);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(1u, id_cube_array);
@@ -780,9 +707,6 @@
   ast::type::I32Type i32;
   ast::type::MultisampledTextureType ms(ast::type::TextureDimension::k2d, &i32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(1u, b.GenerateTypeIfNeeded(&ms));
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
@@ -794,9 +718,6 @@
   ast::type::U32Type u32;
   ast::type::MultisampledTextureType ms(ast::type::TextureDimension::k2d, &u32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ms), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -809,9 +730,6 @@
   ast::type::F32Type f32;
   ast::type::MultisampledTextureType ms(ast::type::TextureDimension::k2d, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&ms), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -824,9 +742,6 @@
   ast::type::I32Type i32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, &i32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -839,9 +754,6 @@
   ast::type::U32Type u32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, &u32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -854,9 +766,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -869,9 +778,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k1dArray, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -884,9 +790,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k2d, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -899,9 +802,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k2dArray, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -914,9 +814,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::k3d, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -929,9 +826,6 @@
   ast::type::F32Type f32;
   ast::type::SampledTextureType s(ast::type::TextureDimension::kCube, &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -945,9 +839,6 @@
   ast::type::SampledTextureType s(ast::type::TextureDimension::kCubeArray,
                                   &f32);
 
-  ast::Module mod;
-  Builder b(&mod);
-
   EXPECT_EQ(b.GenerateTypeIfNeeded(&s), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()),
@@ -957,11 +848,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_1d_R16Float) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1d,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -975,11 +861,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_1d_R8SNorm) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1d,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR8Snorm);
@@ -993,11 +874,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_1d_R8UNorm) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1d,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR8Unorm);
@@ -1011,11 +887,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_1d_array) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1dArray,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1029,11 +900,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_2d) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k2d,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1047,11 +913,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_2dArray) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k2dArray,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1065,11 +926,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateReadonly_3d) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k3d,
                                   ast::AccessControl::kReadOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1083,11 +939,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateWriteonly_1d) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1d,
                                   ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1101,11 +952,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateWriteonly_1dArray) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k1dArray,
                                   ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1119,11 +965,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateWriteonly_2d) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k2d,
                                   ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1137,11 +978,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateWriteonly_2dArray) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k2dArray,
                                   ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1155,11 +991,6 @@
 }
 
 TEST_F(BuilderTest_Type, StorageTexture_GenerateWriteonly_3d) {
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  Builder b(&mod);
-
   ast::type::StorageTextureType s(ast::type::TextureDimension::k3d,
                                   ast::AccessControl::kWriteOnly,
                                   ast::type::ImageFormat::kR16Float);
@@ -1173,9 +1004,6 @@
 }
 
 TEST_F(BuilderTest_Type, Sampler) {
-  ast::Module mod;
-  Builder b(&mod);
-
   ast::type::SamplerType sampler(ast::type::SamplerKind::kSampler);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&sampler), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -1183,9 +1011,6 @@
 }
 
 TEST_F(BuilderTest_Type, ComparisonSampler) {
-  ast::Module mod;
-  Builder b(&mod);
-
   ast::type::SamplerType sampler(ast::type::SamplerKind::kComparisonSampler);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&sampler), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
@@ -1193,9 +1018,6 @@
 }
 
 TEST_F(BuilderTest_Type, Dedup_Sampler_And_ComparisonSampler) {
-  ast::Module mod;
-  Builder b(&mod);
-
   ast::type::SamplerType comp_sampler(
       ast::type::SamplerKind::kComparisonSampler);
   EXPECT_EQ(b.GenerateTypeIfNeeded(&comp_sampler), 1u);
diff --git a/src/writer/spirv/builder_unary_op_expression_test.cc b/src/writer/spirv/builder_unary_op_expression_test.cc
index db07ff6..29f597c 100644
--- a/src/writer/spirv/builder_unary_op_expression_test.cc
+++ b/src/writer/spirv/builder_unary_op_expression_test.cc
@@ -29,13 +29,14 @@
 #include "src/type_determiner.h"
 #include "src/writer/spirv/builder.h"
 #include "src/writer/spirv/spv_dump.h"
+#include "src/writer/spirv/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
-using BuilderTest = testing::Test;
+using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, UnaryOp_Negation_Integer) {
   ast::type::I32Type i32;
@@ -45,13 +46,8 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
@@ -70,13 +66,8 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::FloatLiteral>(&f32, 1)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
@@ -95,13 +86,8 @@
       std::make_unique<ast::ScalarConstructorExpression>(
           std::make_unique<ast::BoolLiteral>(&bool_type, false)));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
@@ -122,13 +108,9 @@
       ast::UnaryOp::kNegation,
       std::make_unique<ast::IdentifierExpression>("param"));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
   td.RegisterVariableForTesting(&var);
   EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
-  Builder b(&mod);
   b.push_function(Function{});
   EXPECT_TRUE(b.GenerateFunctionVariable(&var)) << b.error();
   EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 6u) << b.error();
diff --git a/src/writer/spirv/generator.cc b/src/writer/spirv/generator.cc
index c28cb13..495ddd0 100644
--- a/src/writer/spirv/generator.cc
+++ b/src/writer/spirv/generator.cc
@@ -22,13 +22,18 @@
 
 Generator::Generator(ast::Module module)
     : writer::Writer(std::move(module)),
-      builder_(std::make_unique<Builder>(&module_)),
+      builder_(std::make_unique<Builder>(ctx_, &module_)),
+      writer_(std::make_unique<BinaryWriter>()) {}
+
+Generator::Generator(Context* ctx, ast::Module module)
+    : writer::Writer(ctx, std::move(module)),
+      builder_(std::make_unique<Builder>(ctx, &module_)),
       writer_(std::make_unique<BinaryWriter>()) {}
 
 Generator::~Generator() = default;
 
 void Generator::Reset() {
-  builder_ = std::make_unique<Builder>(&module_);
+  builder_ = std::make_unique<Builder>(ctx_, &module_);
   writer_ = std::make_unique<BinaryWriter>();
 }
 
diff --git a/src/writer/spirv/generator.h b/src/writer/spirv/generator.h
index f5968b2..9687969 100644
--- a/src/writer/spirv/generator.h
+++ b/src/writer/spirv/generator.h
@@ -32,8 +32,13 @@
 class Generator : public writer::Writer {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module the module to convert
   explicit Generator(ast::Module module);
+  /// Constructor
+  /// @param ctx the context, must be non-null
+  /// @param module the module to convert
+  Generator(Context* ctx, ast::Module module);
   ~Generator() override;
 
   /// Resets the generator
diff --git a/src/writer/spirv/test_helper.h b/src/writer/spirv/test_helper.h
new file mode 100644
index 0000000..a7ff015
--- /dev/null
+++ b/src/writer/spirv/test_helper.h
@@ -0,0 +1,53 @@
+// Copyright 2020 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_WRITER_SPIRV_TEST_HELPER_H_
+#define SRC_WRITER_SPIRV_TEST_HELPER_H_
+
+#include "gtest/gtest.h"
+#include "src/ast/module.h"
+#include "src/context.h"
+#include "src/type_determiner.h"
+#include "src/writer/wgsl/generator_impl.h"
+
+namespace tint {
+namespace writer {
+namespace spirv {
+
+/// Helper class for testing
+template <typename T>
+class TestHelperBase : public T {
+ public:
+  TestHelperBase() : td(&ctx, &mod), b(&ctx, &mod) {}
+  ~TestHelperBase() = default;
+
+  /// The context
+  Context ctx;
+  /// The module
+  ast::Module mod;
+  /// The type determiner
+  TypeDeterminer td;
+  /// The generator
+  Builder b;
+};
+using TestHelper = TestHelperBase<testing::Test>;
+
+template <typename T>
+using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
+
+}  // namespace spirv
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_SPIRV_TEST_HELPER_H_
diff --git a/src/writer/text.cc b/src/writer/text.cc
index 319f32e..52929cc 100644
--- a/src/writer/text.cc
+++ b/src/writer/text.cc
@@ -21,6 +21,8 @@
 
 Text::Text(ast::Module module) : Writer(std::move(module)) {}
 
+Text::Text(Context* ctx, ast::Module module) : Writer(ctx, std::move(module)) {}
+
 Text::~Text() = default;
 
 }  // namespace writer
diff --git a/src/writer/text.h b/src/writer/text.h
index 7e4fffc..5f7bb1c 100644
--- a/src/writer/text.h
+++ b/src/writer/text.h
@@ -26,8 +26,13 @@
 class Text : public Writer {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module the module to convert
   explicit Text(ast::Module module);
+  /// Constructor
+  /// @param ctx the context object, must be non-null
+  /// @param module the module to convert
+  Text(Context* ctx, ast::Module module);
   ~Text() override;
 
   /// @returns the result data
diff --git a/src/writer/text_generator.cc b/src/writer/text_generator.cc
index 2c94fdb..52f60e8 100644
--- a/src/writer/text_generator.cc
+++ b/src/writer/text_generator.cc
@@ -14,12 +14,16 @@
 
 #include "src/writer/text_generator.h"
 
+#include <assert.h>
+
 #include <utility>
 
 namespace tint {
 namespace writer {
 
-TextGenerator::TextGenerator() = default;
+TextGenerator::TextGenerator(Context* ctx) : ctx_(ctx) {
+  assert(ctx_);
+}
 
 TextGenerator::~TextGenerator() = default;
 
diff --git a/src/writer/text_generator.h b/src/writer/text_generator.h
index 46da1bc..d38d3ed 100644
--- a/src/writer/text_generator.h
+++ b/src/writer/text_generator.h
@@ -18,6 +18,8 @@
 #include <sstream>
 #include <string>
 
+#include "src/context.h"
+
 namespace tint {
 namespace writer {
 
@@ -25,7 +27,8 @@
 class TextGenerator {
  public:
   /// Constructor
-  TextGenerator();
+  /// @param ctx the context object, must be non-null
+  explicit TextGenerator(Context* ctx);
   ~TextGenerator();
 
   /// Increment the emitter indent level
@@ -49,6 +52,8 @@
   std::string error() const { return error_; }
 
  protected:
+  /// The context
+  Context* ctx_ = nullptr;
   /// The text output stream
   std::ostringstream out_;
   /// Error generated by the generator
diff --git a/src/writer/wgsl/generator.cc b/src/writer/wgsl/generator.cc
index 3f01dc9..93816ed 100644
--- a/src/writer/wgsl/generator.cc
+++ b/src/writer/wgsl/generator.cc
@@ -21,13 +21,17 @@
 namespace wgsl {
 
 Generator::Generator(ast::Module module)
-    : Text(std::move(module)), impl_(std::make_unique<GeneratorImpl>()) {}
+    : Text(std::move(module)), impl_(std::make_unique<GeneratorImpl>(ctx_)) {}
+
+Generator::Generator(Context* ctx, ast::Module module)
+    : Text(ctx, std::move(module)),
+      impl_(std::make_unique<GeneratorImpl>(ctx_)) {}
 
 Generator::~Generator() = default;
 
 void Generator::Reset() {
   set_error("");
-  impl_ = std::make_unique<GeneratorImpl>();
+  impl_ = std::make_unique<GeneratorImpl>(ctx_);
 }
 
 bool Generator::Generate() {
diff --git a/src/writer/wgsl/generator.h b/src/writer/wgsl/generator.h
index 2d3a234..685f7cf 100644
--- a/src/writer/wgsl/generator.h
+++ b/src/writer/wgsl/generator.h
@@ -29,8 +29,13 @@
 class Generator : public Text {
  public:
   /// Constructor
+  /// DEPRECATED
   /// @param module the module to convert
   explicit Generator(ast::Module module);
+  /// Constructor
+  /// @param ctx the context, must be non-null
+  /// @param module the module to convert
+  Generator(Context* ctx, ast::Module module);
   ~Generator() override;
 
   /// Resets the generator
diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc
index 8266900..ddf0717 100644
--- a/src/writer/wgsl/generator_impl.cc
+++ b/src/writer/wgsl/generator_impl.cc
@@ -72,7 +72,7 @@
 namespace writer {
 namespace wgsl {
 
-GeneratorImpl::GeneratorImpl() = default;
+GeneratorImpl::GeneratorImpl(Context* ctx) : TextGenerator(ctx) {}
 
 GeneratorImpl::~GeneratorImpl() = default;
 
diff --git a/src/writer/wgsl/generator_impl.h b/src/writer/wgsl/generator_impl.h
index 081ac4d..bd2451b 100644
--- a/src/writer/wgsl/generator_impl.h
+++ b/src/writer/wgsl/generator_impl.h
@@ -38,7 +38,8 @@
 class GeneratorImpl : public TextGenerator {
  public:
   /// Constructor
-  GeneratorImpl();
+  /// @param ctx the context, must be non-null
+  explicit GeneratorImpl(Context* ctx);
   ~GeneratorImpl();
 
   /// Generates the result data
diff --git a/src/writer/wgsl/generator_impl_alias_type_test.cc b/src/writer/wgsl/generator_impl_alias_type_test.cc
index 0c5e507..346783b 100644
--- a/src/writer/wgsl/generator_impl_alias_type_test.cc
+++ b/src/writer/wgsl/generator_impl_alias_type_test.cc
@@ -21,21 +21,21 @@
 #include "src/ast/type/i32_type.h"
 #include "src/ast/type/struct_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitAliasType_F32) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("a", &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(type a = f32;
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(type a = f32;
 )");
 }
 
@@ -59,10 +59,9 @@
   ast::type::StructType s("A", std::move(str));
   ast::type::AliasType alias("B", &s);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructedType(&s)) << g.error();
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct A {
+  ASSERT_TRUE(gen.EmitConstructedType(&s)) << gen.error();
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct A {
   a : f32;
   [[offset(4)]]
   b : i32;
@@ -91,9 +90,8 @@
   ast::type::StructType s("A", std::move(str));
   ast::type::AliasType alias("B", &s);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructedType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), R"(type B = A;
+  ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(type B = A;
 )");
 }
 
diff --git a/src/writer/wgsl/generator_impl_array_accessor_test.cc b/src/writer/wgsl/generator_impl_array_accessor_test.cc
index 452f582..ca34234 100644
--- a/src/writer/wgsl/generator_impl_array_accessor_test.cc
+++ b/src/writer/wgsl/generator_impl_array_accessor_test.cc
@@ -21,13 +21,14 @@
 #include "src/ast/sint_literal.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) {
   ast::type::I32Type i32;
@@ -37,9 +38,8 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "ary[5]");
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "ary[5]");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitArrayAccessor) {
@@ -48,9 +48,8 @@
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitArrayAccessor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "ary[idx]");
+  ASSERT_TRUE(gen.EmitArrayAccessor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "ary[idx]");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_assign_test.cc b/src/writer/wgsl/generator_impl_assign_test.cc
index c3b7eee..ae2e6e8 100644
--- a/src/writer/wgsl/generator_impl_assign_test.cc
+++ b/src/writer/wgsl/generator_impl_assign_test.cc
@@ -19,24 +19,24 @@
 #include "src/ast/assignment_statement.h"
 #include "src/ast/identifier_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Assign) {
   auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
   auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&assign)) << g.error();
-  EXPECT_EQ(g.result(), "  lhs = rhs;\n");
+  ASSERT_TRUE(gen.EmitStatement(&assign)) << gen.error();
+  EXPECT_EQ(gen.result(), "  lhs = rhs;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_binary_test.cc b/src/writer/wgsl/generator_impl_binary_test.cc
index 2858f77..963e1c1 100644
--- a/src/writer/wgsl/generator_impl_binary_test.cc
+++ b/src/writer/wgsl/generator_impl_binary_test.cc
@@ -18,6 +18,7 @@
 #include "src/ast/binary_expression.h"
 #include "src/ast/identifier_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -32,7 +33,7 @@
   out << data.op;
   return out;
 }
-using WgslBinaryTest = testing::TestWithParam<BinaryData>;
+using WgslBinaryTest = TestParamHelper<BinaryData>;
 TEST_P(WgslBinaryTest, Emit) {
   auto params = GetParam();
 
@@ -41,9 +42,8 @@
 
   ast::BinaryExpression expr(params.op, std::move(left), std::move(right));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), params.result);
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
     WgslGeneratorImplTest,
diff --git a/src/writer/wgsl/generator_impl_bitcast_test.cc b/src/writer/wgsl/generator_impl_bitcast_test.cc
index ac2b940..ee0e204 100644
--- a/src/writer/wgsl/generator_impl_bitcast_test.cc
+++ b/src/writer/wgsl/generator_impl_bitcast_test.cc
@@ -19,22 +19,22 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/type/f32_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Bitcast) {
   ast::type::F32Type f32;
   auto id = std::make_unique<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&f32, std::move(id));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&bitcast)) << g.error();
-  EXPECT_EQ(g.result(), "bitcast<f32>(id)");
+  ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();
+  EXPECT_EQ(gen.result(), "bitcast<f32>(id)");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_block_test.cc b/src/writer/wgsl/generator_impl_block_test.cc
index 43c0286..80c88bb 100644
--- a/src/writer/wgsl/generator_impl_block_test.cc
+++ b/src/writer/wgsl/generator_impl_block_test.cc
@@ -18,23 +18,23 @@
 #include "src/ast/block_statement.h"
 #include "src/ast/discard_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Block) {
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&b)) << g.error();
-  EXPECT_EQ(g.result(), R"(  {
+  ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
     discard;
   }
 )");
@@ -44,11 +44,10 @@
   ast::BlockStatement b;
   b.append(std::make_unique<ast::DiscardStatement>());
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitBlock(&b)) << g.error();
-  EXPECT_EQ(g.result(), R"({
+  ASSERT_TRUE(gen.EmitBlock(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"({
     discard;
   })");
 }
diff --git a/src/writer/wgsl/generator_impl_break_test.cc b/src/writer/wgsl/generator_impl_break_test.cc
index e8d3612..cb909f3 100644
--- a/src/writer/wgsl/generator_impl_break_test.cc
+++ b/src/writer/wgsl/generator_impl_break_test.cc
@@ -18,22 +18,22 @@
 #include "gtest/gtest.h"
 #include "src/ast/break_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Break) {
   ast::BreakStatement b;
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&b)) << g.error();
-  EXPECT_EQ(g.result(), "  break;\n");
+  ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), "  break;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_call_test.cc b/src/writer/wgsl/generator_impl_call_test.cc
index 3ed0b3d..b04c1e0 100644
--- a/src/writer/wgsl/generator_impl_call_test.cc
+++ b/src/writer/wgsl/generator_impl_call_test.cc
@@ -19,21 +19,21 @@
 #include "src/ast/call_statement.h"
 #include "src/ast/identifier_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
   auto id = std::make_unique<ast::IdentifierExpression>("my_func");
   ast::CallExpression call(std::move(id), {});
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "my_func()");
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "my_func()");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithParams) {
@@ -43,9 +43,8 @@
   params.push_back(std::make_unique<ast::IdentifierExpression>("param2"));
   ast::CallExpression call(std::move(id), std::move(params));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
-  EXPECT_EQ(g.result(), "my_func(param1, param2)");
+  ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "my_func(param1, param2)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitStatement_Call) {
@@ -57,10 +56,9 @@
   ast::CallStatement call(
       std::make_unique<ast::CallExpression>(std::move(id), std::move(params)));
 
-  GeneratorImpl g;
-  g.increment_indent();
-  ASSERT_TRUE(g.EmitStatement(&call)) << g.error();
-  EXPECT_EQ(g.result(), "  my_func(param1, param2);\n");
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitStatement(&call)) << gen.error();
+  EXPECT_EQ(gen.result(), "  my_func(param1, param2);\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_case_test.cc b/src/writer/wgsl/generator_impl_case_test.cc
index d389403..0f6dbb6 100644
--- a/src/writer/wgsl/generator_impl_case_test.cc
+++ b/src/writer/wgsl/generator_impl_case_test.cc
@@ -21,13 +21,14 @@
 #include "src/ast/sint_literal.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Case) {
   ast::type::I32Type i32;
@@ -39,11 +40,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
     break;
   }
 )");
@@ -60,11 +60,10 @@
   lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 6));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  case 5, 6: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5, 6: {
     break;
   }
 )");
@@ -77,11 +76,10 @@
   body->append(std::make_unique<ast::BreakStatement>());
   c.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitCase(&c)) << g.error();
-  EXPECT_EQ(g.result(), R"(  default: {
+  ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  default: {
     break;
   }
 )");
diff --git a/src/writer/wgsl/generator_impl_cast_test.cc b/src/writer/wgsl/generator_impl_cast_test.cc
index ee81a66..b69043c 100644
--- a/src/writer/wgsl/generator_impl_cast_test.cc
+++ b/src/writer/wgsl/generator_impl_cast_test.cc
@@ -19,13 +19,14 @@
 #include "src/ast/type/f32_type.h"
 #include "src/ast/type_constructor_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Cast) {
   ast::type::F32Type f32;
@@ -35,9 +36,8 @@
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&cast)) << g.error();
-  EXPECT_EQ(g.result(), "f32(id)");
+  ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
+  EXPECT_EQ(gen.result(), "f32(id)");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_constructor_test.cc b/src/writer/wgsl/generator_impl_constructor_test.cc
index ef21cac..b7620ce 100644
--- a/src/writer/wgsl/generator_impl_constructor_test.cc
+++ b/src/writer/wgsl/generator_impl_constructor_test.cc
@@ -26,22 +26,22 @@
 #include "src/ast/type/vector_type.h"
 #include "src/ast/uint_literal.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) {
   ast::type::BoolType bool_type;
   auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "false");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "false");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) {
@@ -49,9 +49,8 @@
   auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "-12345");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "-12345");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) {
@@ -59,9 +58,8 @@
   auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "56779u");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "56779u");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) {
@@ -71,9 +69,8 @@
       &f32, static_cast<float>((1 << 30) - 4));
   ast::ScalarConstructorExpression expr(std::move(lit));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "1.07374182e+09");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "1.07374182e+09");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) {
@@ -86,9 +83,8 @@
 
   ast::TypeConstructorExpression expr(&f32, std::move(values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "f32(-1.20000004e-05)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "f32(-1.20000004e-05)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) {
@@ -101,9 +97,8 @@
 
   ast::TypeConstructorExpression expr(&b, std::move(values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "bool(true)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "bool(true)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) {
@@ -116,9 +111,8 @@
 
   ast::TypeConstructorExpression expr(&i32, std::move(values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "i32(-12345)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "i32(-12345)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Uint) {
@@ -131,9 +125,8 @@
 
   ast::TypeConstructorExpression expr(&u32, std::move(values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "u32(12345u)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "u32(12345u)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Vec) {
@@ -153,9 +146,8 @@
 
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "vec3<f32>(1.00000000, 2.00000000, 3.00000000)");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "vec3<f32>(1.00000000, 2.00000000, 3.00000000)");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Mat) {
@@ -184,9 +176,8 @@
 
   ast::TypeConstructorExpression expr(&mat, std::move(mat_values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(),
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(),
             std::string("mat2x3<f32>(vec2<f32>(1.00000000, 2.00000000), ") +
                 "vec2<f32>(3.00000000, 4.00000000), " +
                 "vec2<f32>(5.00000000, 6.00000000))");
@@ -221,12 +212,12 @@
 
   ast::TypeConstructorExpression expr(&ary, std::move(ary_values));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitConstructor(&expr)) << g.error();
-  EXPECT_EQ(g.result(), std::string("array<vec3<f32>, 3>(") +
-                            "vec3<f32>(1.00000000, 2.00000000, 3.00000000), " +
-                            "vec3<f32>(4.00000000, 5.00000000, 6.00000000), " +
-                            "vec3<f32>(7.00000000, 8.00000000, 9.00000000))");
+  ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(),
+            std::string("array<vec3<f32>, 3>(") +
+                "vec3<f32>(1.00000000, 2.00000000, 3.00000000), " +
+                "vec3<f32>(4.00000000, 5.00000000, 6.00000000), " +
+                "vec3<f32>(7.00000000, 8.00000000, 9.00000000))");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_continue_test.cc b/src/writer/wgsl/generator_impl_continue_test.cc
index 6e8bde2..48d033e 100644
--- a/src/writer/wgsl/generator_impl_continue_test.cc
+++ b/src/writer/wgsl/generator_impl_continue_test.cc
@@ -18,22 +18,22 @@
 #include "gtest/gtest.h"
 #include "src/ast/continue_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Continue) {
   ast::ContinueStatement c;
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&c)) << g.error();
-  EXPECT_EQ(g.result(), "  continue;\n");
+  ASSERT_TRUE(gen.EmitStatement(&c)) << gen.error();
+  EXPECT_EQ(gen.result(), "  continue;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_discard_test.cc b/src/writer/wgsl/generator_impl_discard_test.cc
index 9e87437..092d197 100644
--- a/src/writer/wgsl/generator_impl_discard_test.cc
+++ b/src/writer/wgsl/generator_impl_discard_test.cc
@@ -15,22 +15,22 @@
 #include "gtest/gtest.h"
 #include "src/ast/discard_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Discard) {
   ast::DiscardStatement k;
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&k)) << g.error();
-  EXPECT_EQ(g.result(), "  discard;\n");
+  ASSERT_TRUE(gen.EmitStatement(&k)) << gen.error();
+  EXPECT_EQ(gen.result(), "  discard;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_fallthrough_test.cc b/src/writer/wgsl/generator_impl_fallthrough_test.cc
index bbe3547..e8fcbe4 100644
--- a/src/writer/wgsl/generator_impl_fallthrough_test.cc
+++ b/src/writer/wgsl/generator_impl_fallthrough_test.cc
@@ -15,22 +15,22 @@
 #include "gtest/gtest.h"
 #include "src/ast/fallthrough_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Fallthrough) {
   ast::FallthroughStatement f;
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&f)) << g.error();
-  EXPECT_EQ(g.result(), "  fallthrough;\n");
+  ASSERT_TRUE(gen.EmitStatement(&f)) << gen.error();
+  EXPECT_EQ(gen.result(), "  fallthrough;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_function_test.cc b/src/writer/wgsl/generator_impl_function_test.cc
index f7ba33b..08f77f2 100644
--- a/src/writer/wgsl/generator_impl_function_test.cc
+++ b/src/writer/wgsl/generator_impl_function_test.cc
@@ -33,13 +33,14 @@
 #include "src/context.h"
 #include "src/type_determiner.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Function) {
   auto body = std::make_unique<ast::BlockStatement>();
@@ -50,11 +51,10 @@
   ast::Function func("my_func", {}, &void_type);
   func.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitFunction(&func));
-  EXPECT_EQ(g.result(), R"(  fn my_func() -> void {
+  ASSERT_TRUE(gen.EmitFunction(&func));
+  EXPECT_EQ(gen.result(), R"(  fn my_func() -> void {
     discard;
     return;
   }
@@ -78,11 +78,10 @@
   ast::Function func("my_func", std::move(params), &void_type);
   func.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitFunction(&func));
-  EXPECT_EQ(g.result(), R"(  fn my_func(a : f32, b : i32) -> void {
+  ASSERT_TRUE(gen.EmitFunction(&func));
+  EXPECT_EQ(gen.result(), R"(  fn my_func(a : f32, b : i32) -> void {
     discard;
     return;
   }
@@ -100,11 +99,10 @@
       std::make_unique<ast::WorkgroupDecoration>(2u, 4u, 6u, Source{}));
   func.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitFunction(&func));
-  EXPECT_EQ(g.result(), R"(  [[workgroup_size(2, 4, 6)]]
+  ASSERT_TRUE(gen.EmitFunction(&func));
+  EXPECT_EQ(gen.result(), R"(  [[workgroup_size(2, 4, 6)]]
   fn my_func() -> void {
     discard;
     return;
@@ -123,11 +121,10 @@
       ast::PipelineStage::kFragment, Source{}));
   func.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitFunction(&func));
-  EXPECT_EQ(g.result(), R"(  [[stage(fragment)]]
+  ASSERT_TRUE(gen.EmitFunction(&func));
+  EXPECT_EQ(gen.result(), R"(  [[stage(fragment)]]
   fn my_func() -> void {
     discard;
     return;
@@ -148,11 +145,10 @@
       std::make_unique<ast::WorkgroupDecoration>(2u, 4u, 6u, Source{}));
   func.set_body(std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitFunction(&func));
-  EXPECT_EQ(g.result(), R"(  [[stage(fragment)]]
+  ASSERT_TRUE(gen.EmitFunction(&func));
+  EXPECT_EQ(gen.result(), R"(  [[stage(fragment)]]
   [[workgroup_size(2, 4, 6)]]
   fn my_func() -> void {
     discard;
@@ -207,10 +203,6 @@
   decos.push_back(std::make_unique<ast::SetDecoration>(0, Source{}));
   data_var->set_decorations(std::move(decos));
 
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
   mod.AddConstructedType(&s);
 
   td.RegisterVariableForTesting(data_var.get());
@@ -260,9 +252,8 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.Generate(mod)) << g.error();
-  EXPECT_EQ(g.result(), R"([[block]]
+  ASSERT_TRUE(gen.Generate(mod)) << gen.error();
+  EXPECT_EQ(gen.result(), R"([[block]]
 struct Data {
   [[offset(0)]]
   d : f32;
diff --git a/src/writer/wgsl/generator_impl_identifier_test.cc b/src/writer/wgsl/generator_impl_identifier_test.cc
index 503579a..d0f6b31 100644
--- a/src/writer/wgsl/generator_impl_identifier_test.cc
+++ b/src/writer/wgsl/generator_impl_identifier_test.cc
@@ -14,20 +14,20 @@
 
 #include "gtest/gtest.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) {
   ast::IdentifierExpression i("glsl");
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "glsl");
+  ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), "glsl");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_if_test.cc b/src/writer/wgsl/generator_impl_if_test.cc
index 985f6da..f024782 100644
--- a/src/writer/wgsl/generator_impl_if_test.cc
+++ b/src/writer/wgsl/generator_impl_if_test.cc
@@ -18,13 +18,14 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/if_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_If) {
   auto cond = std::make_unique<ast::IdentifierExpression>("cond");
@@ -33,11 +34,10 @@
 
   ast::IfStatement i(std::move(cond), std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     discard;
   }
 )");
@@ -59,11 +59,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     discard;
   } elseif (else_cond) {
     discard;
@@ -85,11 +84,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     discard;
   } else {
     discard;
@@ -118,11 +116,10 @@
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&i)) << g.error();
-  EXPECT_EQ(g.result(), R"(  if (cond) {
+  ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
     discard;
   } elseif (else_cond) {
     discard;
diff --git a/src/writer/wgsl/generator_impl_loop_test.cc b/src/writer/wgsl/generator_impl_loop_test.cc
index e440234..2371ac6 100644
--- a/src/writer/wgsl/generator_impl_loop_test.cc
+++ b/src/writer/wgsl/generator_impl_loop_test.cc
@@ -18,24 +18,24 @@
 #include "src/ast/discard_statement.h"
 #include "src/ast/loop_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Loop) {
   auto body = std::make_unique<ast::BlockStatement>();
   body->append(std::make_unique<ast::DiscardStatement>());
   ast::LoopStatement l(std::move(body), {});
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&l)) << g.error();
-  EXPECT_EQ(g.result(), R"(  loop {
+  ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  loop {
     discard;
   }
 )");
@@ -50,11 +50,10 @@
 
   ast::LoopStatement l(std::move(body), std::move(continuing));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&l)) << g.error();
-  EXPECT_EQ(g.result(), R"(  loop {
+  ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  loop {
     discard;
 
     continuing {
diff --git a/src/writer/wgsl/generator_impl_member_accessor_test.cc b/src/writer/wgsl/generator_impl_member_accessor_test.cc
index 4c9eaf6..437bb0a 100644
--- a/src/writer/wgsl/generator_impl_member_accessor_test.cc
+++ b/src/writer/wgsl/generator_impl_member_accessor_test.cc
@@ -18,13 +18,14 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/member_accessor_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) {
   auto str = std::make_unique<ast::IdentifierExpression>("str");
@@ -32,9 +33,8 @@
 
   ast::MemberAccessorExpression expr(std::move(str), std::move(mem));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&expr)) << g.error();
-  EXPECT_EQ(g.result(), "str.mem");
+  ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+  EXPECT_EQ(gen.result(), "str.mem");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_return_test.cc b/src/writer/wgsl/generator_impl_return_test.cc
index 4701813..1d90af8 100644
--- a/src/writer/wgsl/generator_impl_return_test.cc
+++ b/src/writer/wgsl/generator_impl_return_test.cc
@@ -19,33 +19,32 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/return_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Return) {
   ast::ReturnStatement r;
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&r)) << g.error();
-  EXPECT_EQ(g.result(), "  return;\n");
+  ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return;\n");
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_ReturnWithValue) {
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::ReturnStatement r(std::move(expr));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&r)) << g.error();
-  EXPECT_EQ(g.result(), "  return expr;\n");
+  ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return expr;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_switch_test.cc b/src/writer/wgsl/generator_impl_switch_test.cc
index ceecb80..8994ba8 100644
--- a/src/writer/wgsl/generator_impl_switch_test.cc
+++ b/src/writer/wgsl/generator_impl_switch_test.cc
@@ -22,13 +22,14 @@
 #include "src/ast/switch_statement.h"
 #include "src/ast/type/i32_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Switch) {
   auto def = std::make_unique<ast::CaseStatement>();
@@ -53,11 +54,10 @@
   auto cond = std::make_unique<ast::IdentifierExpression>("cond");
   ast::SwitchStatement s(std::move(cond), std::move(body));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(  switch(cond) {
+  ASSERT_TRUE(gen.EmitStatement(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  switch(cond) {
     case 5: {
       break;
     }
diff --git a/src/writer/wgsl/generator_impl_test.cc b/src/writer/wgsl/generator_impl_test.cc
index 675111d..2f6da33 100644
--- a/src/writer/wgsl/generator_impl_test.cc
+++ b/src/writer/wgsl/generator_impl_test.cc
@@ -20,25 +20,23 @@
 #include "src/ast/function.h"
 #include "src/ast/module.h"
 #include "src/ast/type/void_type.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Generate) {
   ast::type::VoidType void_type;
 
-  ast::Module m;
-  m.AddFunction(std::make_unique<ast::Function>("my_func", ast::VariableList{},
-                                                &void_type));
+  mod.AddFunction(std::make_unique<ast::Function>(
+      "my_func", ast::VariableList{}, &void_type));
 
-  GeneratorImpl g;
-
-  ASSERT_TRUE(g.Generate(m)) << g.error();
-  EXPECT_EQ(g.result(), R"(fn my_func() -> void {
+  ASSERT_TRUE(gen.Generate(mod)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(fn my_func() -> void {
 }
 
 )");
diff --git a/src/writer/wgsl/generator_impl_type_test.cc b/src/writer/wgsl/generator_impl_type_test.cc
index ec5d0ee..aeaf721 100644
--- a/src/writer/wgsl/generator_impl_type_test.cc
+++ b/src/writer/wgsl/generator_impl_type_test.cc
@@ -36,30 +36,29 @@
 #include "src/ast/type/vector_type.h"
 #include "src/ast/type/void_type.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitType_Alias) {
   ast::type::F32Type f32;
   ast::type::AliasType alias("alias", &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&alias)) << g.error();
-  EXPECT_EQ(g.result(), "alias");
+  ASSERT_TRUE(gen.EmitType(&alias)) << gen.error();
+  EXPECT_EQ(gen.result(), "alias");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Array) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b, 4);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&a)) << g.error();
-  EXPECT_EQ(g.result(), "array<bool, 4>");
+  ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
+  EXPECT_EQ(gen.result(), "array<bool, 4>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Array_Decoration) {
@@ -70,9 +69,8 @@
   ast::type::ArrayType a(&b, 4);
   a.set_decorations(std::move(decos));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&a)) << g.error();
-  EXPECT_EQ(g.result(), "[[stride(16)]] array<bool, 4>");
+  ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
+  EXPECT_EQ(gen.result(), "[[stride(16)]] array<bool, 4>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Array_MultipleDecorations) {
@@ -84,60 +82,53 @@
   ast::type::ArrayType a(&b, 4);
   a.set_decorations(std::move(decos));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&a)) << g.error();
-  EXPECT_EQ(g.result(), "[[stride(16)]] [[stride(32)]] array<bool, 4>");
+  ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
+  EXPECT_EQ(gen.result(), "[[stride(16)]] [[stride(32)]] array<bool, 4>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_RuntimeArray) {
   ast::type::BoolType b;
   ast::type::ArrayType a(&b);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&a)) << g.error();
-  EXPECT_EQ(g.result(), "array<bool>");
+  ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
+  EXPECT_EQ(gen.result(), "array<bool>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Bool) {
   ast::type::BoolType b;
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&b)) << g.error();
-  EXPECT_EQ(g.result(), "bool");
+  ASSERT_TRUE(gen.EmitType(&b)) << gen.error();
+  EXPECT_EQ(gen.result(), "bool");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_F32) {
   ast::type::F32Type f32;
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&f32)) << g.error();
-  EXPECT_EQ(g.result(), "f32");
+  ASSERT_TRUE(gen.EmitType(&f32)) << gen.error();
+  EXPECT_EQ(gen.result(), "f32");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_I32) {
   ast::type::I32Type i32;
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&i32)) << g.error();
-  EXPECT_EQ(g.result(), "i32");
+  ASSERT_TRUE(gen.EmitType(&i32)) << gen.error();
+  EXPECT_EQ(gen.result(), "i32");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Matrix) {
   ast::type::F32Type f32;
   ast::type::MatrixType m(&f32, 3, 2);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&m)) << g.error();
-  EXPECT_EQ(g.result(), "mat2x3<f32>");
+  ASSERT_TRUE(gen.EmitType(&m)) << gen.error();
+  EXPECT_EQ(gen.result(), "mat2x3<f32>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Pointer) {
   ast::type::F32Type f32;
   ast::type::PointerType p(&f32, ast::StorageClass::kWorkgroup);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&p)) << g.error();
-  EXPECT_EQ(g.result(), "ptr<workgroup, f32>");
+  ASSERT_TRUE(gen.EmitType(&p)) << gen.error();
+  EXPECT_EQ(gen.result(), "ptr<workgroup, f32>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Struct) {
@@ -159,9 +150,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&s)) << g.error();
-  EXPECT_EQ(g.result(), "S");
+  ASSERT_TRUE(gen.EmitType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), "S");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_StructDecl) {
@@ -183,9 +173,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitStructType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"(struct S {
+  ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct S {
   a : i32;
   [[offset(4)]]
   b : f32;
@@ -215,9 +204,8 @@
 
   ast::type::StructType s("S", std::move(str));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitStructType(&s)) << g.error();
-  EXPECT_EQ(g.result(), R"([[block]]
+  ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"([[block]]
 struct S {
   a : i32;
   [[offset(4)]]
@@ -229,26 +217,23 @@
 TEST_F(WgslGeneratorImplTest, EmitType_U32) {
   ast::type::U32Type u32;
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&u32)) << g.error();
-  EXPECT_EQ(g.result(), "u32");
+  ASSERT_TRUE(gen.EmitType(&u32)) << gen.error();
+  EXPECT_EQ(gen.result(), "u32");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Vector) {
   ast::type::F32Type f32;
   ast::type::VectorType v(&f32, 3);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&v)) << g.error();
-  EXPECT_EQ(g.result(), "vec3<f32>");
+  ASSERT_TRUE(gen.EmitType(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), "vec3<f32>");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_Void) {
   ast::type::VoidType v;
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&v)) << g.error();
-  EXPECT_EQ(g.result(), "void");
+  ASSERT_TRUE(gen.EmitType(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), "void");
 }
 
 struct TextureData {
@@ -259,16 +244,15 @@
   out << data.name;
   return out;
 }
-using WgslGenerator_DepthTextureTest = testing::TestWithParam<TextureData>;
+using WgslGenerator_DepthTextureTest = TestParamHelper<TextureData>;
 
 TEST_P(WgslGenerator_DepthTextureTest, EmitType_DepthTexture) {
   auto param = GetParam();
 
   ast::type::DepthTextureType d(param.dim);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&d)) << g.error();
-  EXPECT_EQ(g.result(), param.name);
+  ASSERT_TRUE(gen.EmitType(&d)) << gen.error();
+  EXPECT_EQ(gen.result(), param.name);
 }
 INSTANTIATE_TEST_SUITE_P(
     WgslGeneratorImplTest,
@@ -281,16 +265,15 @@
         TextureData{ast::type::TextureDimension::kCubeArray,
                     "texture_depth_cube_array"}));
 
-using WgslGenerator_SampledTextureTest = testing::TestWithParam<TextureData>;
+using WgslGenerator_SampledTextureTest = TestParamHelper<TextureData>;
 TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_F32) {
   auto param = GetParam();
 
   ast::type::F32Type f32;
   ast::type::SampledTextureType t(param.dim, &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<f32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>");
 }
 
 TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_I32) {
@@ -299,9 +282,8 @@
   ast::type::I32Type i32;
   ast::type::SampledTextureType t(param.dim, &i32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<i32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>");
 }
 
 TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_U32) {
@@ -310,9 +292,8 @@
   ast::type::U32Type u32;
   ast::type::SampledTextureType t(param.dim, &u32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<u32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>");
 }
 INSTANTIATE_TEST_SUITE_P(
     WgslGeneratorImplTest,
@@ -327,17 +308,15 @@
         TextureData{ast::type::TextureDimension::kCubeArray,
                     "texture_cube_array"}));
 
-using WgslGenerator_MultiampledTextureTest =
-    testing::TestWithParam<TextureData>;
+using WgslGenerator_MultiampledTextureTest = TestParamHelper<TextureData>;
 TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_F32) {
   auto param = GetParam();
 
   ast::type::F32Type f32;
   ast::type::MultisampledTextureType t(param.dim, &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<f32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>");
 }
 
 TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_I32) {
@@ -346,9 +325,8 @@
   ast::type::I32Type i32;
   ast::type::MultisampledTextureType t(param.dim, &i32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<i32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>");
 }
 
 TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_U32) {
@@ -357,9 +335,8 @@
   ast::type::U32Type u32;
   ast::type::MultisampledTextureType t(param.dim, &u32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), std::string(param.name) + "<u32>");
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>");
 }
 INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest,
                          WgslGenerator_MultiampledTextureTest,
@@ -377,16 +354,14 @@
   out << data.name;
   return out;
 }
-using WgslGenerator_StorageTextureTest =
-    testing::TestWithParam<StorageTextureData>;
+using WgslGenerator_StorageTextureTest = TestParamHelper<StorageTextureData>;
 TEST_P(WgslGenerator_StorageTextureTest, EmitType_StorageTexture) {
   auto param = GetParam();
 
   ast::type::StorageTextureType t(param.dim, param.access, param.fmt);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&t)) << g.error();
-  EXPECT_EQ(g.result(), param.name);
+  ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
+  EXPECT_EQ(gen.result(), param.name);
 }
 INSTANTIATE_TEST_SUITE_P(
     WgslGeneratorImplTest,
@@ -435,13 +410,12 @@
   out << data.name;
   return out;
 }
-using WgslGenerator_ImageFormatTest = testing::TestWithParam<ImageFormatData>;
+using WgslGenerator_ImageFormatTest = TestParamHelper<ImageFormatData>;
 TEST_P(WgslGenerator_ImageFormatTest, EmitType_StorageTexture_ImageFormat) {
   auto param = GetParam();
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitImageFormat(param.fmt)) << g.error();
-  EXPECT_EQ(g.result(), param.name);
+  ASSERT_TRUE(gen.EmitImageFormat(param.fmt)) << gen.error();
+  EXPECT_EQ(gen.result(), param.name);
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -489,17 +463,15 @@
 TEST_F(WgslGeneratorImplTest, EmitType_Sampler) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kSampler);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&sampler)) << g.error();
-  EXPECT_EQ(g.result(), "sampler");
+  ASSERT_TRUE(gen.EmitType(&sampler)) << gen.error();
+  EXPECT_EQ(gen.result(), "sampler");
 }
 
 TEST_F(WgslGeneratorImplTest, EmitType_SamplerComparison) {
   ast::type::SamplerType sampler(ast::type::SamplerKind::kComparisonSampler);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitType(&sampler)) << g.error();
-  EXPECT_EQ(g.result(), "sampler_comparison");
+  ASSERT_TRUE(gen.EmitType(&sampler)) << gen.error();
+  EXPECT_EQ(gen.result(), "sampler_comparison");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_unary_op_test.cc b/src/writer/wgsl/generator_impl_unary_op_test.cc
index 44bc4a2..5ed2345 100644
--- a/src/writer/wgsl/generator_impl_unary_op_test.cc
+++ b/src/writer/wgsl/generator_impl_unary_op_test.cc
@@ -19,6 +19,7 @@
 #include "src/ast/identifier_expression.h"
 #include "src/ast/unary_op_expression.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
@@ -33,16 +34,15 @@
   out << data.op;
   return out;
 }
-using WgslUnaryOpTest = testing::TestWithParam<UnaryOpData>;
+using WgslUnaryOpTest = TestParamHelper<UnaryOpData>;
 TEST_P(WgslUnaryOpTest, Emit) {
   auto params = GetParam();
 
   auto expr = std::make_unique<ast::IdentifierExpression>("expr");
   ast::UnaryOpExpression op(params.op, std::move(expr));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&op)) << g.error();
-  EXPECT_EQ(g.result(), std::string(params.name) + "(expr)");
+  ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();
+  EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
 }
 INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest,
                          WgslUnaryOpTest,
diff --git a/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc b/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
index 2e0e03a..828b23a 100644
--- a/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
@@ -21,13 +21,14 @@
 #include "src/ast/variable.h"
 #include "src/ast/variable_decl_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement) {
   ast::type::F32Type f32;
@@ -36,11 +37,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  var a : f32;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  var a : f32;\n");
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement_Function) {
@@ -53,11 +53,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  var a : f32;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  var a : f32;\n");
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
@@ -67,11 +66,10 @@
 
   ast::VariableDeclStatement stmt(std::move(var));
 
-  GeneratorImpl g;
-  g.increment_indent();
+  gen.increment_indent();
 
-  ASSERT_TRUE(g.EmitStatement(&stmt)) << g.error();
-  EXPECT_EQ(g.result(), "  var<private> a : f32;\n");
+  ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  var<private> a : f32;\n");
 }
 
 }  // namespace
diff --git a/src/writer/wgsl/generator_impl_variable_test.cc b/src/writer/wgsl/generator_impl_variable_test.cc
index 053f640..4414596 100644
--- a/src/writer/wgsl/generator_impl_variable_test.cc
+++ b/src/writer/wgsl/generator_impl_variable_test.cc
@@ -24,21 +24,21 @@
 #include "src/ast/type/f32_type.h"
 #include "src/ast/variable_decoration.h"
 #include "src/writer/wgsl/generator_impl.h"
+#include "src/writer/wgsl/test_helper.h"
 
 namespace tint {
 namespace writer {
 namespace wgsl {
 namespace {
 
-using WgslGeneratorImplTest = testing::Test;
+using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitVariable) {
   ast::type::F32Type f32;
   ast::Variable v("a", ast::StorageClass::kNone, &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&v)) << g.error();
-  EXPECT_EQ(g.result(), R"(var a : f32;
+  ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(var a : f32;
 )");
 }
 
@@ -46,9 +46,8 @@
   ast::type::F32Type f32;
   ast::Variable v("a", ast::StorageClass::kInput, &f32);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&v)) << g.error();
-  EXPECT_EQ(g.result(), R"(var<in> a : f32;
+  ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(var<in> a : f32;
 )");
 }
 
@@ -63,9 +62,8 @@
   dv.set_type(&f32);
   dv.set_decorations(std::move(decos));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&dv)) << g.error();
-  EXPECT_EQ(g.result(), R"([[location(2)]] var a : f32;
+  ASSERT_TRUE(gen.EmitVariable(&dv)) << gen.error();
+  EXPECT_EQ(gen.result(), R"([[location(2)]] var a : f32;
 )");
 }
 
@@ -85,10 +83,9 @@
   dv.set_type(&f32);
   dv.set_decorations(std::move(decos));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&dv)) << g.error();
+  ASSERT_TRUE(gen.EmitVariable(&dv)) << gen.error();
   EXPECT_EQ(
-      g.result(),
+      gen.result(),
       R"([[builtin(position), binding(0), set(1), location(2), constant_id(42)]] var a : f32;
 )");
 }
@@ -100,9 +97,8 @@
   ast::Variable v("a", ast::StorageClass::kNone, &f32);
   v.set_constructor(std::move(ident));
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&v)) << g.error();
-  EXPECT_EQ(g.result(), R"(var a : f32 = initializer;
+  ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(var a : f32 = initializer;
 )");
 }
 
@@ -114,9 +110,8 @@
   v.set_constructor(std::move(ident));
   v.set_is_const(true);
 
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitVariable(&v)) << g.error();
-  EXPECT_EQ(g.result(), R"(const a : f32 = initializer;
+  ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(const a : f32 = initializer;
 )");
 }
 
diff --git a/src/writer/wgsl/test_helper.h b/src/writer/wgsl/test_helper.h
new file mode 100644
index 0000000..91e37af
--- /dev/null
+++ b/src/writer/wgsl/test_helper.h
@@ -0,0 +1,54 @@
+// Copyright 2020 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_WRITER_WGSL_TEST_HELPER_H_
+#define SRC_WRITER_WGSL_TEST_HELPER_H_
+
+#include "gtest/gtest.h"
+#include "src/ast/module.h"
+#include "src/context.h"
+#include "src/type_determiner.h"
+#include "src/writer/wgsl/generator_impl.h"
+
+namespace tint {
+namespace writer {
+namespace wgsl {
+
+/// Helper class for testing
+template <typename T>
+class TestHelperBase : public T {
+ public:
+  TestHelperBase() : td(&ctx, &mod), gen(&ctx) {}
+
+  ~TestHelperBase() = default;
+
+  /// The context
+  Context ctx;
+  /// The module
+  ast::Module mod;
+  /// The type determiner
+  TypeDeterminer td;
+  /// The generator
+  GeneratorImpl gen;
+};
+using TestHelper = TestHelperBase<testing::Test>;
+
+template <typename T>
+using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
+
+}  // namespace wgsl
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_WGSL_TEST_HELPER_H_
diff --git a/src/writer/writer.cc b/src/writer/writer.cc
index 545ed3b..c41b556 100644
--- a/src/writer/writer.cc
+++ b/src/writer/writer.cc
@@ -19,9 +19,18 @@
 namespace tint {
 namespace writer {
 
-Writer::Writer(ast::Module module) : module_(std::move(module)) {}
+Writer::Writer(ast::Module module)
+    : ctx_(new Context()),
+      context_is_owned_(true),
+      module_(std::move(module)) {}
 
-Writer::~Writer() = default;
+Writer::Writer(Context* ctx, ast::Module module)
+    : ctx_(ctx), context_is_owned_(false), module_(std::move(module)) {}
+
+Writer::~Writer() {
+  if (context_is_owned_)
+    delete ctx_;
+}
 
 }  // namespace writer
 }  // namespace tint
diff --git a/src/writer/writer.h b/src/writer/writer.h
index b38657b..3caf73e 100644
--- a/src/writer/writer.h
+++ b/src/writer/writer.h
@@ -19,6 +19,7 @@
 
 #include "src/ast/module.h"
 #include "src/ast/pipeline_stage.h"
+#include "src/context.h"
 
 namespace tint {
 namespace writer {
@@ -49,15 +50,25 @@
 
  protected:
   /// Constructor
+  /// DEPRECATED
   /// @param module the tint module to convert
   explicit Writer(ast::Module module);
 
+  /// Constructor
+  /// @param ctx the context object, must be non-null
+  /// @param module the tint module to convert
+  Writer(Context* ctx, ast::Module module);
+
   /// Sets the error string
   /// @param msg the error message
   void set_error(const std::string& msg) { error_ = msg; }
 
   /// An error message, if an error was encountered
   std::string error_;
+  /// The context
+  Context* ctx_ = nullptr;
+  /// Tracks if we own the context
+  bool context_is_owned_ = false;
   /// The module being converted
   ast::Module module_;
 };