diff --git a/src/tint/lang/spirv/writer/access_test.cc b/src/tint/lang/spirv/writer/access_test.cc
index d511269..96b7831 100644
--- a/src/tint/lang/spirv/writer/access_test.cc
+++ b/src/tint/lang/spirv/writer/access_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Access_Array_Value_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Array_Value_ConstantIndex) {
     auto* arr_val = b.FunctionParam("arr", ty.array(ty.i32(), 4));
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({arr_val});
@@ -34,7 +34,7 @@
     EXPECT_INST("%result = OpCompositeExtract %int %arr 1");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Array_Pointer_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Array_Pointer_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* arr_var = b.Var("arr", ty.ptr<function, array<i32, 4>>());
@@ -47,7 +47,7 @@
     EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %arr %uint_1");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Array_Pointer_DynamicIndex) {
+TEST_F(SpirvWriterTest, Access_Array_Pointer_DynamicIndex) {
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({idx});
@@ -62,7 +62,7 @@
     EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %arr %idx");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Matrix_Value_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Matrix_Value_ConstantIndex) {
     auto* mat_val = b.FunctionParam("mat", ty.mat2x2(ty.f32()));
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({mat_val});
@@ -79,7 +79,7 @@
     EXPECT_INST("%result_scalar = OpCompositeExtract %float %mat 1 0");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Matrix_Pointer_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Matrix_Pointer_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* mat_var = b.Var("mat", ty.ptr<function, mat2x2<f32>>());
@@ -96,7 +96,7 @@
     EXPECT_INST("%result_scalar = OpLoad %float %14");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Matrix_Pointer_DynamicIndex) {
+TEST_F(SpirvWriterTest, Access_Matrix_Pointer_DynamicIndex) {
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({idx});
@@ -115,7 +115,7 @@
     EXPECT_INST("%result_scalar = OpLoad %float %14");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Vector_Value_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Vector_Value_ConstantIndex) {
     auto* vec_val = b.FunctionParam("vec", ty.vec4(ty.i32()));
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({vec_val});
@@ -129,7 +129,7 @@
     EXPECT_INST("%result = OpCompositeExtract %int %vec 1");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Vector_Value_DynamicIndex) {
+TEST_F(SpirvWriterTest, Access_Vector_Value_DynamicIndex) {
     auto* vec_val = b.FunctionParam("vec", ty.vec4(ty.i32()));
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
@@ -144,7 +144,7 @@
     EXPECT_INST("%result = OpVectorExtractDynamic %int %vec %idx");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_NestedVector_Value_DynamicIndex) {
+TEST_F(SpirvWriterTest, Access_NestedVector_Value_DynamicIndex) {
     auto* val = b.FunctionParam("arr", ty.array(ty.array(ty.vec4(ty.i32()), 4), 4));
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
@@ -160,7 +160,7 @@
     EXPECT_INST("%result = OpVectorExtractDynamic %int %14 %idx");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Struct_Value_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Struct_Value_ConstantIndex) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.f32()},
@@ -182,7 +182,7 @@
     EXPECT_INST("%result_b = OpCompositeExtract %int %str 1 2");
 }
 
-TEST_F(SpvGeneratorImplTest, Access_Struct_Pointer_ConstantIndex) {
+TEST_F(SpirvWriterTest, Access_Struct_Pointer_ConstantIndex) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.f32()},
@@ -203,7 +203,7 @@
     EXPECT_INST("%result_b = OpAccessChain %_ptr_Function_v4int %str %uint_1");
 }
 
-TEST_F(SpvGeneratorImplTest, LoadVectorElement_ConstantIndex) {
+TEST_F(SpirvWriterTest, LoadVectorElement_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* vec_var = b.Var("vec", ty.ptr<function, vec4<i32>>());
@@ -217,7 +217,7 @@
     EXPECT_INST("%result = OpLoad %int %9");
 }
 
-TEST_F(SpvGeneratorImplTest, LoadVectorElement_DynamicIndex) {
+TEST_F(SpirvWriterTest, LoadVectorElement_DynamicIndex) {
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({idx});
@@ -233,7 +233,7 @@
     EXPECT_INST("%result = OpLoad %int %10");
 }
 
-TEST_F(SpvGeneratorImplTest, StoreVectorElement_ConstantIndex) {
+TEST_F(SpirvWriterTest, StoreVectorElement_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* vec_var = b.Var("vec", ty.ptr<function, vec4<i32>>());
@@ -246,7 +246,7 @@
     EXPECT_INST("OpStore %9 %int_42");
 }
 
-TEST_F(SpvGeneratorImplTest, StoreVectorElement_DynamicIndex) {
+TEST_F(SpirvWriterTest, StoreVectorElement_DynamicIndex) {
     auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({idx});
diff --git a/src/tint/lang/spirv/writer/atomic_builtin_test.cc b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
index e68cb8d..2b32fed 100644
--- a/src/tint/lang/spirv/writer/atomic_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
@@ -23,7 +23,7 @@
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, AtomicAdd_Storage) {
+TEST_F(SpirvWriterTest, AtomicAdd_Storage) {
     auto* var = b.Var("var", ty.ptr(storage, ty.atomic(ty.i32())));
     var->SetBindingPoint(0, 0);
     b.RootBlock()->Append(var);
@@ -43,7 +43,7 @@
     EXPECT_INST("%result = OpAtomicIAdd %int %ptr %uint_1 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicAdd_Workgroup) {
+TEST_F(SpirvWriterTest, AtomicAdd_Workgroup) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -60,7 +60,7 @@
     EXPECT_INST("%result = OpAtomicIAdd %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicAnd) {
+TEST_F(SpirvWriterTest, AtomicAnd) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -77,7 +77,7 @@
     EXPECT_INST("%result = OpAtomicAnd %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicCompareExchangeWeak) {
+TEST_F(SpirvWriterTest, AtomicCompareExchangeWeak) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* cmp = b.FunctionParam("cmp", ty.i32());
@@ -102,7 +102,7 @@
     EXPECT_INST("%original = OpCompositeExtract %int %result 0");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicExchange) {
+TEST_F(SpirvWriterTest, AtomicExchange) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -119,7 +119,7 @@
     EXPECT_INST("%result = OpAtomicExchange %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicLoad) {
+TEST_F(SpirvWriterTest, AtomicLoad) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* func = b.Function("foo", ty.i32());
@@ -134,7 +134,7 @@
     EXPECT_INST("%result = OpAtomicLoad %int %var %uint_2 %uint_0");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicMax_I32) {
+TEST_F(SpirvWriterTest, AtomicMax_I32) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -151,7 +151,7 @@
     EXPECT_INST("%result = OpAtomicSMax %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicMax_U32) {
+TEST_F(SpirvWriterTest, AtomicMax_U32) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.u32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.u32());
@@ -168,7 +168,7 @@
     EXPECT_INST("%result = OpAtomicUMax %uint %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicMin_I32) {
+TEST_F(SpirvWriterTest, AtomicMin_I32) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -185,7 +185,7 @@
     EXPECT_INST("%result = OpAtomicSMin %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicMin_U32) {
+TEST_F(SpirvWriterTest, AtomicMin_U32) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.u32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.u32());
@@ -202,7 +202,7 @@
     EXPECT_INST("%result = OpAtomicUMin %uint %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicOr) {
+TEST_F(SpirvWriterTest, AtomicOr) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -219,7 +219,7 @@
     EXPECT_INST("%result = OpAtomicOr %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicStore) {
+TEST_F(SpirvWriterTest, AtomicStore) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -235,7 +235,7 @@
     EXPECT_INST("OpAtomicStore %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicSub) {
+TEST_F(SpirvWriterTest, AtomicSub) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
@@ -252,7 +252,7 @@
     EXPECT_INST("%result = OpAtomicISub %int %var %uint_2 %uint_0 %arg1");
 }
 
-TEST_F(SpvGeneratorImplTest, AtomicXor) {
+TEST_F(SpirvWriterTest, AtomicXor) {
     auto* var = b.RootBlock()->Append(b.Var("var", ty.ptr(workgroup, ty.atomic(ty.i32()))));
 
     auto* arg1 = b.FunctionParam("arg1", ty.i32());
diff --git a/src/tint/lang/spirv/writer/binary_test.cc b/src/tint/lang/spirv/writer/binary_test.cc
index b18a46f..c35134d 100644
--- a/src/tint/lang/spirv/writer/binary_test.cc
+++ b/src/tint/lang/spirv/writer/binary_test.cc
@@ -33,7 +33,7 @@
     std::string spirv_type_name;
 };
 
-using Arithmetic_Bitwise = SpvGeneratorImplTestWithParam<BinaryTestCase>;
+using Arithmetic_Bitwise = SpirvWriterTestWithParam<BinaryTestCase>;
 TEST_P(Arithmetic_Bitwise, Scalar) {
     auto params = GetParam();
 
@@ -65,7 +65,7 @@
     EXPECT_INST("%result = " + params.spirv_inst + " %v2" + params.spirv_type_name);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_I32,
+    SpirvWriterTest_Binary_I32,
     Arithmetic_Bitwise,
     testing::Values(BinaryTestCase{kI32, ir::Binary::Kind::kAdd, "OpIAdd", "int"},
                     BinaryTestCase{kI32, ir::Binary::Kind::kSubtract, "OpISub", "int"},
@@ -79,7 +79,7 @@
                     BinaryTestCase{kI32, ir::Binary::Kind::kShiftRight, "OpShiftRightArithmetic",
                                    "int"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_U32,
+    SpirvWriterTest_Binary_U32,
     Arithmetic_Bitwise,
     testing::Values(
         BinaryTestCase{kU32, ir::Binary::Kind::kAdd, "OpIAdd", "uint"},
@@ -93,7 +93,7 @@
         BinaryTestCase{kU32, ir::Binary::Kind::kShiftLeft, "OpShiftLeftLogical", "uint"},
         BinaryTestCase{kU32, ir::Binary::Kind::kShiftRight, "OpShiftRightLogical", "uint"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_F32,
+    SpirvWriterTest_Binary_F32,
     Arithmetic_Bitwise,
     testing::Values(BinaryTestCase{kF32, ir::Binary::Kind::kAdd, "OpFAdd", "float"},
                     BinaryTestCase{kF32, ir::Binary::Kind::kSubtract, "OpFSub", "float"},
@@ -101,7 +101,7 @@
                     BinaryTestCase{kF32, ir::Binary::Kind::kDivide, "OpFDiv", "float"},
                     BinaryTestCase{kF32, ir::Binary::Kind::kModulo, "OpFRem", "float"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_F16,
+    SpirvWriterTest_Binary_F16,
     Arithmetic_Bitwise,
     testing::Values(BinaryTestCase{kF16, ir::Binary::Kind::kAdd, "OpFAdd", "half"},
                     BinaryTestCase{kF16, ir::Binary::Kind::kSubtract, "OpFSub", "half"},
@@ -109,12 +109,12 @@
                     BinaryTestCase{kF16, ir::Binary::Kind::kDivide, "OpFDiv", "half"},
                     BinaryTestCase{kF16, ir::Binary::Kind::kModulo, "OpFRem", "half"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_Bool,
+    SpirvWriterTest_Binary_Bool,
     Arithmetic_Bitwise,
     testing::Values(BinaryTestCase{kBool, ir::Binary::Kind::kAnd, "OpLogicalAnd", "bool"},
                     BinaryTestCase{kBool, ir::Binary::Kind::kOr, "OpLogicalOr", "bool"}));
 
-TEST_F(SpvGeneratorImplTest, Binary_ScalarTimesVector_F32) {
+TEST_F(SpirvWriterTest, Binary_ScalarTimesVector_F32) {
     auto* scalar = b.FunctionParam("scalar", ty.f32());
     auto* vector = b.FunctionParam("vector", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -129,7 +129,7 @@
     EXPECT_INST("%result = OpVectorTimesScalar %v4float %vector %scalar");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_VectorTimesScalar_F32) {
+TEST_F(SpirvWriterTest, Binary_VectorTimesScalar_F32) {
     auto* scalar = b.FunctionParam("scalar", ty.f32());
     auto* vector = b.FunctionParam("vector", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -144,7 +144,7 @@
     EXPECT_INST("%result = OpVectorTimesScalar %v4float %vector %scalar");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_ScalarTimesMatrix_F32) {
+TEST_F(SpirvWriterTest, Binary_ScalarTimesMatrix_F32) {
     auto* scalar = b.FunctionParam("scalar", ty.f32());
     auto* matrix = b.FunctionParam("matrix", ty.mat3x4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -159,7 +159,7 @@
     EXPECT_INST("%result = OpMatrixTimesScalar %mat3v4float %matrix %scalar");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_MatrixTimesScalar_F32) {
+TEST_F(SpirvWriterTest, Binary_MatrixTimesScalar_F32) {
     auto* scalar = b.FunctionParam("scalar", ty.f32());
     auto* matrix = b.FunctionParam("matrix", ty.mat3x4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -174,7 +174,7 @@
     EXPECT_INST("%result = OpMatrixTimesScalar %mat3v4float %matrix %scalar");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_VectorTimesMatrix_F32) {
+TEST_F(SpirvWriterTest, Binary_VectorTimesMatrix_F32) {
     auto* vector = b.FunctionParam("vector", ty.vec4<f32>());
     auto* matrix = b.FunctionParam("matrix", ty.mat3x4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -189,7 +189,7 @@
     EXPECT_INST("%result = OpVectorTimesMatrix %v3float %vector %matrix");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_MatrixTimesVector_F32) {
+TEST_F(SpirvWriterTest, Binary_MatrixTimesVector_F32) {
     auto* vector = b.FunctionParam("vector", ty.vec3<f32>());
     auto* matrix = b.FunctionParam("matrix", ty.mat3x4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -204,7 +204,7 @@
     EXPECT_INST("%result = OpMatrixTimesVector %v4float %matrix %vector");
 }
 
-TEST_F(SpvGeneratorImplTest, Binary_MatrixTimesMatrix_F32) {
+TEST_F(SpirvWriterTest, Binary_MatrixTimesMatrix_F32) {
     auto* mat1 = b.FunctionParam("mat1", ty.mat4x3<f32>());
     auto* mat2 = b.FunctionParam("mat2", ty.mat3x4<f32>());
     auto* func = b.Function("foo", ty.void_());
@@ -219,7 +219,7 @@
     EXPECT_INST("%result = OpMatrixTimesMatrix %mat3v3float %mat1 %mat2");
 }
 
-using Comparison = SpvGeneratorImplTestWithParam<BinaryTestCase>;
+using Comparison = SpirvWriterTestWithParam<BinaryTestCase>;
 TEST_P(Comparison, Scalar) {
     auto params = GetParam();
 
@@ -252,7 +252,7 @@
     EXPECT_INST("%result = " + params.spirv_inst + " %v2bool");
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_I32,
+    SpirvWriterTest_Binary_I32,
     Comparison,
     testing::Values(
         BinaryTestCase{kI32, ir::Binary::Kind::kEqual, "OpIEqual", "bool"},
@@ -262,7 +262,7 @@
         BinaryTestCase{kI32, ir::Binary::Kind::kLessThan, "OpSLessThan", "bool"},
         BinaryTestCase{kI32, ir::Binary::Kind::kLessThanEqual, "OpSLessThanEqual", "bool"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_U32,
+    SpirvWriterTest_Binary_U32,
     Comparison,
     testing::Values(
         BinaryTestCase{kU32, ir::Binary::Kind::kEqual, "OpIEqual", "bool"},
@@ -272,7 +272,7 @@
         BinaryTestCase{kU32, ir::Binary::Kind::kLessThan, "OpULessThan", "bool"},
         BinaryTestCase{kU32, ir::Binary::Kind::kLessThanEqual, "OpULessThanEqual", "bool"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_F32,
+    SpirvWriterTest_Binary_F32,
     Comparison,
     testing::Values(
         BinaryTestCase{kF32, ir::Binary::Kind::kEqual, "OpFOrdEqual", "bool"},
@@ -282,7 +282,7 @@
         BinaryTestCase{kF32, ir::Binary::Kind::kLessThan, "OpFOrdLessThan", "bool"},
         BinaryTestCase{kF32, ir::Binary::Kind::kLessThanEqual, "OpFOrdLessThanEqual", "bool"}));
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Binary_F16,
+    SpirvWriterTest_Binary_F16,
     Comparison,
     testing::Values(
         BinaryTestCase{kF16, ir::Binary::Kind::kEqual, "OpFOrdEqual", "bool"},
@@ -291,14 +291,14 @@
         BinaryTestCase{kF16, ir::Binary::Kind::kGreaterThanEqual, "OpFOrdGreaterThanEqual", "bool"},
         BinaryTestCase{kF16, ir::Binary::Kind::kLessThan, "OpFOrdLessThan", "bool"},
         BinaryTestCase{kF16, ir::Binary::Kind::kLessThanEqual, "OpFOrdLessThanEqual", "bool"}));
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest_Binary_Bool,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest_Binary_Bool,
                          Comparison,
                          testing::Values(BinaryTestCase{kBool, ir::Binary::Kind::kEqual,
                                                         "OpLogicalEqual", "bool"},
                                          BinaryTestCase{kBool, ir::Binary::Kind::kNotEqual,
                                                         "OpLogicalNotEqual", "bool"}));
 
-TEST_F(SpvGeneratorImplTest, Binary_Chain) {
+TEST_F(SpirvWriterTest, Binary_Chain) {
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
diff --git a/src/tint/lang/spirv/writer/bitcast_test.cc b/src/tint/lang/spirv/writer/bitcast_test.cc
index 84d31d1..74ad148 100644
--- a/src/tint/lang/spirv/writer/bitcast_test.cc
+++ b/src/tint/lang/spirv/writer/bitcast_test.cc
@@ -35,7 +35,7 @@
     return ss.str();
 }
 
-using Bitcast = SpvGeneratorImplTestWithParam<BitcastCase>;
+using Bitcast = SpirvWriterTestWithParam<BitcastCase>;
 TEST_P(Bitcast, Scalar) {
     auto& params = GetParam();
     auto* func = b.Function("foo", MakeScalarType(params.out));
@@ -70,7 +70,7 @@
         EXPECT_INST("%result = OpBitcast %v2" + params.spirv_type_name + " %arg");
     }
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          Bitcast,
                          testing::Values(
                              // To f32.
@@ -92,7 +92,7 @@
                              BitcastCase{kU32, kU32, "uint"}),
                          PrintCase);
 
-TEST_F(SpvGeneratorImplTest, Bitcast_u32_to_vec2h) {
+TEST_F(SpirvWriterTest, Bitcast_u32_to_vec2h) {
     auto* func = b.Function("foo", ty.vec2<f16>());
     func->SetParams({b.FunctionParam("arg", ty.u32())});
     b.With(func->Block(), [&] {
@@ -105,7 +105,7 @@
     EXPECT_INST("%result = OpBitcast %v2half %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Bitcast_vec2i_to_vec4h) {
+TEST_F(SpirvWriterTest, Bitcast_vec2i_to_vec4h) {
     auto* func = b.Function("foo", ty.vec4<f16>());
     func->SetParams({b.FunctionParam("arg", ty.vec2<i32>())});
     b.With(func->Block(), [&] {
@@ -118,7 +118,7 @@
     EXPECT_INST("%result = OpBitcast %v4half %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Bitcast_vec2h_to_u32) {
+TEST_F(SpirvWriterTest, Bitcast_vec2h_to_u32) {
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({b.FunctionParam("arg", ty.vec2<f16>())});
     b.With(func->Block(), [&] {
@@ -131,7 +131,7 @@
     EXPECT_INST("%result = OpBitcast %uint %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Bitcast_vec4h_to_vec2i) {
+TEST_F(SpirvWriterTest, Bitcast_vec4h_to_vec2i) {
     auto* func = b.Function("foo", ty.vec2<i32>());
     func->SetParams({b.FunctionParam("arg", ty.vec4<f16>())});
     b.With(func->Block(), [&] {
diff --git a/src/tint/lang/spirv/writer/builtin_test.cc b/src/tint/lang/spirv/writer/builtin_test.cc
index 2340fe8..5ff4998 100644
--- a/src/tint/lang/spirv/writer/builtin_test.cc
+++ b/src/tint/lang/spirv/writer/builtin_test.cc
@@ -33,7 +33,7 @@
 };
 
 // Tests for builtins with the signature: T = func(T)
-using Builtin_1arg = SpvGeneratorImplTestWithParam<BuiltinTestCase>;
+using Builtin_1arg = SpirvWriterTestWithParam<BuiltinTestCase>;
 TEST_P(Builtin_1arg, Scalar) {
     auto params = GetParam();
 
@@ -59,7 +59,7 @@
     EXPECT_INST(params.spirv_inst);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     Builtin_1arg,
     testing::Values(BuiltinTestCase{kI32, builtin::Function::kAbs, "SAbs"},
                     BuiltinTestCase{kF32, builtin::Function::kAbs, "FAbs"},
@@ -133,7 +133,7 @@
                     BuiltinTestCase{kF16, builtin::Function::kTanh, "Tanh"}));
 
 // Test that abs of an unsigned value just folds away.
-TEST_F(SpvGeneratorImplTest, Builtin_Abs_u32) {
+TEST_F(SpirvWriterTest, Builtin_Abs_u32) {
     auto* func = b.Function("foo", MakeScalarType(kU32));
     b.With(func->Block(), [&] {
         auto* arg = MakeScalarValue(kU32);
@@ -151,7 +151,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Abs_vec2u) {
+TEST_F(SpirvWriterTest, Builtin_Abs_vec2u) {
     auto* func = b.Function("foo", MakeVectorType(kU32));
     b.With(func->Block(), [&] {
         auto* arg = MakeVectorValue(kU32);
@@ -170,7 +170,7 @@
 }
 
 // Test that all of a scalar just folds away.
-TEST_F(SpvGeneratorImplTest, Builtin_All_Scalar) {
+TEST_F(SpirvWriterTest, Builtin_All_Scalar) {
     auto* arg = b.FunctionParam("arg", ty.bool_());
     auto* func = b.Function("foo", ty.bool_());
     func->SetParams({arg});
@@ -183,7 +183,7 @@
     EXPECT_INST("OpReturnValue %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_All_Vector) {
+TEST_F(SpirvWriterTest, Builtin_All_Vector) {
     auto* arg = b.FunctionParam("arg", ty.vec4<bool>());
     auto* func = b.Function("foo", ty.bool_());
     func->SetParams({arg});
@@ -198,7 +198,7 @@
 }
 
 // Test that any of a scalar just folds away.
-TEST_F(SpvGeneratorImplTest, Builtin_Any_Scalar) {
+TEST_F(SpirvWriterTest, Builtin_Any_Scalar) {
     auto* arg = b.FunctionParam("arg", ty.bool_());
     auto* func = b.Function("foo", ty.bool_());
     func->SetParams({arg});
@@ -211,7 +211,7 @@
     EXPECT_INST("OpReturnValue %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Any_Vector) {
+TEST_F(SpirvWriterTest, Builtin_Any_Vector) {
     auto* arg = b.FunctionParam("arg", ty.vec4<bool>());
     auto* func = b.Function("foo", ty.bool_());
     func->SetParams({arg});
@@ -225,7 +225,7 @@
     EXPECT_INST("%result = OpAny %bool %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Frexp_F32) {
+TEST_F(SpirvWriterTest, Builtin_Frexp_F32) {
     auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.f32());
     auto* arg = b.FunctionParam("arg", ty.f32());
     auto* func = b.Function("foo", str);
@@ -240,7 +240,7 @@
     EXPECT_INST("%result = OpExtInst %__frexp_result_f32 %9 FrexpStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Frexp_F16) {
+TEST_F(SpirvWriterTest, Builtin_Frexp_F16) {
     auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.f16());
     auto* arg = b.FunctionParam("arg", ty.f16());
     auto* func = b.Function("foo", str);
@@ -255,7 +255,7 @@
     EXPECT_INST("%result = OpExtInst %__frexp_result_f16 %9 FrexpStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Frexp_Vec2f) {
+TEST_F(SpirvWriterTest, Builtin_Frexp_Vec2f) {
     auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.vec2<f32>());
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", str);
@@ -270,7 +270,7 @@
     EXPECT_INST("%result = OpExtInst %__frexp_result_vec2_f32 %11 FrexpStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Frexp_Vec3h) {
+TEST_F(SpirvWriterTest, Builtin_Frexp_Vec3h) {
     auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.vec3<f16>());
     auto* arg = b.FunctionParam("arg", ty.vec3<f16>());
     auto* func = b.Function("foo", str);
@@ -285,7 +285,7 @@
     EXPECT_INST("%result = OpExtInst %__frexp_result_vec3_f16 %11 FrexpStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Length_vec4f) {
+TEST_F(SpirvWriterTest, Builtin_Length_vec4f) {
     auto* arg = b.FunctionParam("arg", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.f32());
     func->SetParams({arg});
@@ -299,7 +299,7 @@
     EXPECT_INST("%result = OpExtInst %float %8 Length %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Modf_F32) {
+TEST_F(SpirvWriterTest, Builtin_Modf_F32) {
     auto* str = type::CreateModfResult(ty, mod.symbols, ty.f32());
     auto* arg = b.FunctionParam("arg", ty.f32());
     auto* func = b.Function("foo", str);
@@ -314,7 +314,7 @@
     EXPECT_INST("%result = OpExtInst %__modf_result_f32 %8 ModfStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Modf_F16) {
+TEST_F(SpirvWriterTest, Builtin_Modf_F16) {
     auto* str = type::CreateModfResult(ty, mod.symbols, ty.f16());
     auto* arg = b.FunctionParam("arg", ty.f16());
     auto* func = b.Function("foo", str);
@@ -329,7 +329,7 @@
     EXPECT_INST("%result = OpExtInst %__modf_result_f16 %8 ModfStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Modf_Vec2f) {
+TEST_F(SpirvWriterTest, Builtin_Modf_Vec2f) {
     auto* str = type::CreateModfResult(ty, mod.symbols, ty.vec2<f32>());
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", str);
@@ -344,7 +344,7 @@
     EXPECT_INST("%result = OpExtInst %__modf_result_vec2_f32 %9 ModfStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Modf_Vec3h) {
+TEST_F(SpirvWriterTest, Builtin_Modf_Vec3h) {
     auto* str = type::CreateModfResult(ty, mod.symbols, ty.vec3<f16>());
     auto* arg = b.FunctionParam("arg", ty.vec3<f16>());
     auto* func = b.Function("foo", str);
@@ -359,7 +359,7 @@
     EXPECT_INST("%result = OpExtInst %__modf_result_vec3_f16 %9 ModfStruct %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Normalize_vec4f) {
+TEST_F(SpirvWriterTest, Builtin_Normalize_vec4f) {
     auto* arg = b.FunctionParam("arg", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.vec4<f32>());
     func->SetParams({arg});
@@ -373,7 +373,7 @@
     EXPECT_INST("%result = OpExtInst %v4float %8 Normalize %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Transpose_Mat2x3f) {
+TEST_F(SpirvWriterTest, Builtin_Transpose_Mat2x3f) {
     auto* arg = b.FunctionParam("arg", ty.mat2x3<f32>());
     auto* func = b.Function("foo", ty.mat3x2<f32>());
     func->SetParams({arg});
@@ -387,7 +387,7 @@
     EXPECT_INST("%result = OpTranspose %mat3v2float %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Transpose_Mat4x4f) {
+TEST_F(SpirvWriterTest, Builtin_Transpose_Mat4x4f) {
     auto* arg = b.FunctionParam("arg", ty.mat4x4<f32>());
     auto* func = b.Function("foo", ty.mat4x4<f32>());
     func->SetParams({arg});
@@ -401,7 +401,7 @@
     EXPECT_INST("%result = OpTranspose %mat4v4float %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Transpose_Mat4x3h) {
+TEST_F(SpirvWriterTest, Builtin_Transpose_Mat4x3h) {
     auto* arg = b.FunctionParam("arg", ty.mat4x3<f16>());
     auto* func = b.Function("foo", ty.mat3x4<f16>());
     func->SetParams({arg});
@@ -415,7 +415,7 @@
     EXPECT_INST("%result = OpTranspose %mat3v4half %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Transpose_Mat2x2h) {
+TEST_F(SpirvWriterTest, Builtin_Transpose_Mat2x2h) {
     auto* arg = b.FunctionParam("arg", ty.mat2x2<f16>());
     auto* func = b.Function("foo", ty.mat2x2<f16>());
     func->SetParams({arg});
@@ -429,7 +429,7 @@
     EXPECT_INST("%result = OpTranspose %mat2v2half %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Pack2X16Float) {
+TEST_F(SpirvWriterTest, Builtin_Pack2X16Float) {
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({arg});
@@ -443,7 +443,7 @@
     EXPECT_INST("%result = OpExtInst %uint %9 PackHalf2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Pack2X16Snorm) {
+TEST_F(SpirvWriterTest, Builtin_Pack2X16Snorm) {
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({arg});
@@ -457,7 +457,7 @@
     EXPECT_INST("%result = OpExtInst %uint %9 PackSnorm2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Pack2X16Unorm) {
+TEST_F(SpirvWriterTest, Builtin_Pack2X16Unorm) {
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({arg});
@@ -471,7 +471,7 @@
     EXPECT_INST("%result = OpExtInst %uint %9 PackUnorm2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Pack4X8Snorm) {
+TEST_F(SpirvWriterTest, Builtin_Pack4X8Snorm) {
     auto* arg = b.FunctionParam("arg", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({arg});
@@ -485,7 +485,7 @@
     EXPECT_INST("%result = OpExtInst %uint %9 PackSnorm4x8 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Pack4X8Unorm) {
+TEST_F(SpirvWriterTest, Builtin_Pack4X8Unorm) {
     auto* arg = b.FunctionParam("arg", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({arg});
@@ -499,7 +499,7 @@
     EXPECT_INST("%result = OpExtInst %uint %9 PackUnorm4x8 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Unpack2X16Float) {
+TEST_F(SpirvWriterTest, Builtin_Unpack2X16Float) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* func = b.Function("foo", ty.vec2<f32>());
     func->SetParams({arg});
@@ -513,7 +513,7 @@
     EXPECT_INST("%result = OpExtInst %v2float %9 UnpackHalf2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Unpack2X16Snorm) {
+TEST_F(SpirvWriterTest, Builtin_Unpack2X16Snorm) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* func = b.Function("foo", ty.vec2<f32>());
     func->SetParams({arg});
@@ -527,7 +527,7 @@
     EXPECT_INST("%result = OpExtInst %v2float %9 UnpackSnorm2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Unpack2X16Unorm) {
+TEST_F(SpirvWriterTest, Builtin_Unpack2X16Unorm) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* func = b.Function("foo", ty.vec2<f32>());
     func->SetParams({arg});
@@ -541,7 +541,7 @@
     EXPECT_INST("%result = OpExtInst %v2float %9 UnpackUnorm2x16 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Unpack4X8Snorm) {
+TEST_F(SpirvWriterTest, Builtin_Unpack4X8Snorm) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* func = b.Function("foo", ty.vec4<f32>());
     func->SetParams({arg});
@@ -555,7 +555,7 @@
     EXPECT_INST("%result = OpExtInst %v4float %9 UnpackSnorm4x8 %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Unpack4X8Unorm) {
+TEST_F(SpirvWriterTest, Builtin_Unpack4X8Unorm) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* func = b.Function("foo", ty.vec4<f32>());
     func->SetParams({arg});
@@ -570,7 +570,7 @@
 }
 
 // Tests for builtins with the signature: T = func(T, T)
-using Builtin_2arg = SpvGeneratorImplTestWithParam<BuiltinTestCase>;
+using Builtin_2arg = SpirvWriterTestWithParam<BuiltinTestCase>;
 TEST_P(Builtin_2arg, Scalar) {
     auto params = GetParam();
 
@@ -597,7 +597,7 @@
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST(params.spirv_inst);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          Builtin_2arg,
                          testing::Values(BuiltinTestCase{kF32, builtin::Function::kAtan2, "Atan2"},
                                          BuiltinTestCase{kF32, builtin::Function::kMax, "FMax"},
@@ -611,7 +611,7 @@
                                          BuiltinTestCase{kF32, builtin::Function::kStep, "Step"},
                                          BuiltinTestCase{kF16, builtin::Function::kStep, "Step"}));
 
-TEST_F(SpvGeneratorImplTest, Builtin_Cross_vec3f) {
+TEST_F(SpirvWriterTest, Builtin_Cross_vec3f) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec3<f32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec3<f32>());
     auto* func = b.Function("foo", ty.vec3<f32>());
@@ -626,7 +626,7 @@
     EXPECT_INST("%result = OpExtInst %v3float %9 Cross %arg1 %arg2");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Distance_vec2f) {
+TEST_F(SpirvWriterTest, Builtin_Distance_vec2f) {
     auto* arg1 = b.FunctionParam("arg1", MakeVectorType(kF32));
     auto* arg2 = b.FunctionParam("arg2", MakeVectorType(kF32));
     auto* func = b.Function("foo", MakeScalarType(kF32));
@@ -641,7 +641,7 @@
     EXPECT_INST("%result = OpExtInst %float %9 Distance %arg1 %arg2");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Distance_vec3h) {
+TEST_F(SpirvWriterTest, Builtin_Distance_vec3h) {
     auto* arg1 = b.FunctionParam("arg1", MakeVectorType(kF16));
     auto* arg2 = b.FunctionParam("arg2", MakeVectorType(kF16));
     auto* func = b.Function("foo", MakeScalarType(kF16));
@@ -656,7 +656,7 @@
     EXPECT_INST("%result = OpExtInst %half %9 Distance %arg1 %arg2");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Dot_vec4f) {
+TEST_F(SpirvWriterTest, Builtin_Dot_vec4f) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec4<f32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec4<f32>());
     auto* func = b.Function("foo", ty.f32());
@@ -671,7 +671,7 @@
     EXPECT_INST("%result = OpDot %float %arg1 %arg2");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Dot_vec2i) {
+TEST_F(SpirvWriterTest, Builtin_Dot_vec2i) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec2<i32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec2<i32>());
     auto* func = b.Function("foo", ty.i32());
@@ -694,7 +694,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Dot_vec4u) {
+TEST_F(SpirvWriterTest, Builtin_Dot_vec4u) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec4<u32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec4<u32>());
     auto* func = b.Function("foo", ty.u32());
@@ -726,7 +726,7 @@
 }
 
 // Tests for builtins with the signature: T = func(T, T, T)
-using Builtin_3arg = SpvGeneratorImplTestWithParam<BuiltinTestCase>;
+using Builtin_3arg = SpirvWriterTestWithParam<BuiltinTestCase>;
 TEST_P(Builtin_3arg, Scalar) {
     auto params = GetParam();
 
@@ -754,7 +754,7 @@
     EXPECT_INST(params.spirv_inst);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     Builtin_3arg,
     testing::Values(BuiltinTestCase{kF32, builtin::Function::kClamp, "NClamp"},
                     BuiltinTestCase{kI32, builtin::Function::kClamp, "SClamp"},
@@ -766,7 +766,7 @@
                     BuiltinTestCase{kF32, builtin::Function::kSmoothstep, "SmoothStep"},
                     BuiltinTestCase{kF16, builtin::Function::kSmoothstep, "SmoothStep"}));
 
-TEST_F(SpvGeneratorImplTest, Builtin_ExtractBits_Scalar_I32) {
+TEST_F(SpirvWriterTest, Builtin_ExtractBits_Scalar_I32) {
     auto* arg = b.FunctionParam("arg", ty.i32());
     auto* offset = b.FunctionParam("offset", ty.u32());
     auto* count = b.FunctionParam("count", ty.u32());
@@ -783,7 +783,7 @@
     EXPECT_INST("%result = OpBitFieldSExtract %int %arg %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_ExtractBits_Scalar_U32) {
+TEST_F(SpirvWriterTest, Builtin_ExtractBits_Scalar_U32) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* offset = b.FunctionParam("offset", ty.u32());
     auto* count = b.FunctionParam("count", ty.u32());
@@ -800,7 +800,7 @@
     EXPECT_INST("%result = OpBitFieldUExtract %uint %arg %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_ExtractBits_Vector_I32) {
+TEST_F(SpirvWriterTest, Builtin_ExtractBits_Vector_I32) {
     auto* arg = b.FunctionParam("arg", ty.vec4<i32>());
     auto* offset = b.FunctionParam("offset", ty.u32());
     auto* count = b.FunctionParam("count", ty.u32());
@@ -817,7 +817,7 @@
     EXPECT_INST("%result = OpBitFieldSExtract %v4int %arg %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_ExtractBits_Vector_U32) {
+TEST_F(SpirvWriterTest, Builtin_ExtractBits_Vector_U32) {
     auto* arg = b.FunctionParam("arg", ty.vec2<u32>());
     auto* offset = b.FunctionParam("offset", ty.u32());
     auto* count = b.FunctionParam("count", ty.u32());
@@ -834,7 +834,7 @@
     EXPECT_INST("%result = OpBitFieldUExtract %v2uint %arg %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_InsertBits_Scalar_I32) {
+TEST_F(SpirvWriterTest, Builtin_InsertBits_Scalar_I32) {
     auto* arg = b.FunctionParam("arg", ty.i32());
     auto* newbits = b.FunctionParam("newbits", ty.i32());
     auto* offset = b.FunctionParam("offset", ty.u32());
@@ -853,7 +853,7 @@
     EXPECT_INST("%result = OpBitFieldInsert %int %arg %newbits %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_InsertBits_Scalar_U32) {
+TEST_F(SpirvWriterTest, Builtin_InsertBits_Scalar_U32) {
     auto* arg = b.FunctionParam("arg", ty.u32());
     auto* newbits = b.FunctionParam("newbits", ty.u32());
     auto* offset = b.FunctionParam("offset", ty.u32());
@@ -872,7 +872,7 @@
     EXPECT_INST("%result = OpBitFieldInsert %uint %arg %newbits %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_InsertBits_Vector_I32) {
+TEST_F(SpirvWriterTest, Builtin_InsertBits_Vector_I32) {
     auto* arg = b.FunctionParam("arg", ty.vec4<i32>());
     auto* newbits = b.FunctionParam("newbits", ty.vec4<i32>());
     auto* offset = b.FunctionParam("offset", ty.u32());
@@ -891,7 +891,7 @@
     EXPECT_INST("%result = OpBitFieldInsert %v4int %arg %newbits %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_InsertBits_Vector_U32) {
+TEST_F(SpirvWriterTest, Builtin_InsertBits_Vector_U32) {
     auto* arg = b.FunctionParam("arg", ty.vec2<u32>());
     auto* newbits = b.FunctionParam("newbits", ty.vec2<u32>());
     auto* offset = b.FunctionParam("offset", ty.u32());
@@ -910,7 +910,7 @@
     EXPECT_INST("%result = OpBitFieldInsert %v2uint %arg %newbits %offset %count");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Mix_VectorOperands_ScalarFactor) {
+TEST_F(SpirvWriterTest, Builtin_Mix_VectorOperands_ScalarFactor) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec4<f32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec4<f32>());
     auto* factor = b.FunctionParam("factor", ty.f32());
@@ -928,7 +928,7 @@
     EXPECT_INST("%result = OpExtInst %v4float %11 FMix %arg1 %arg2 %9");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Mix_VectorOperands_VectorFactor) {
+TEST_F(SpirvWriterTest, Builtin_Mix_VectorOperands_VectorFactor) {
     auto* arg1 = b.FunctionParam("arg1", ty.vec4<f32>());
     auto* arg2 = b.FunctionParam("arg2", ty.vec4<f32>());
     auto* factor = b.FunctionParam("factor", ty.vec4<f32>());
@@ -945,7 +945,7 @@
     EXPECT_INST("%result = OpExtInst %v4float %10 FMix %arg1 %arg2 %factor");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Select_ScalarCondition_ScalarOperands) {
+TEST_F(SpirvWriterTest, Builtin_Select_ScalarCondition_ScalarOperands) {
     auto* argf = b.FunctionParam("argf", ty.i32());
     auto* argt = b.FunctionParam("argt", ty.i32());
     auto* cond = b.FunctionParam("cond", ty.bool_());
@@ -962,7 +962,7 @@
     EXPECT_INST("%result = OpSelect %int %cond %argt %argf");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Select_VectorCondition_VectorOperands) {
+TEST_F(SpirvWriterTest, Builtin_Select_VectorCondition_VectorOperands) {
     auto* argf = b.FunctionParam("argf", ty.vec4<i32>());
     auto* argt = b.FunctionParam("argt", ty.vec4<i32>());
     auto* cond = b.FunctionParam("cond", ty.vec4<bool>());
@@ -979,7 +979,7 @@
     EXPECT_INST("%result = OpSelect %v4int %cond %argt %argf");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_Select_ScalarCondition_VectorOperands) {
+TEST_F(SpirvWriterTest, Builtin_Select_ScalarCondition_VectorOperands) {
     auto* argf = b.FunctionParam("argf", ty.vec4<i32>());
     auto* argt = b.FunctionParam("argt", ty.vec4<i32>());
     auto* cond = b.FunctionParam("cond", ty.bool_());
@@ -997,7 +997,7 @@
     EXPECT_INST("%result = OpSelect %v4int %11 %argt %argf");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_StorageBarrier) {
+TEST_F(SpirvWriterTest, Builtin_StorageBarrier) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         b.Call(ty.void_(), builtin::Function::kStorageBarrier);
@@ -1008,7 +1008,7 @@
     EXPECT_INST("OpControlBarrier %uint_2 %uint_2 %uint_72");
 }
 
-TEST_F(SpvGeneratorImplTest, Builtin_WorkgroupBarrier) {
+TEST_F(SpirvWriterTest, Builtin_WorkgroupBarrier) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         b.Call(ty.void_(), builtin::Function::kWorkgroupBarrier);
diff --git a/src/tint/lang/spirv/writer/constant_test.cc b/src/tint/lang/spirv/writer/constant_test.cc
index fafa974..db5c2fe 100644
--- a/src/tint/lang/spirv/writer/constant_test.cc
+++ b/src/tint/lang/spirv/writer/constant_test.cc
@@ -19,7 +19,7 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Constant_Bool) {
+TEST_F(SpirvWriterTest, Constant_Bool) {
     generator_.Constant(b.Constant(true));
     generator_.Constant(b.Constant(false));
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -27,7 +27,7 @@
     EXPECT_INST("%false = OpConstantFalse %bool");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_I32) {
+TEST_F(SpirvWriterTest, Constant_I32) {
     generator_.Constant(b.Constant(i32(42)));
     generator_.Constant(b.Constant(i32(-1)));
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -35,7 +35,7 @@
     EXPECT_INST("%int_n1 = OpConstant %int -1");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_U32) {
+TEST_F(SpirvWriterTest, Constant_U32) {
     generator_.Constant(b.Constant(u32(42)));
     generator_.Constant(b.Constant(u32(4000000000)));
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -43,7 +43,7 @@
     EXPECT_INST("%uint_4000000000 = OpConstant %uint 4000000000");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_F32) {
+TEST_F(SpirvWriterTest, Constant_F32) {
     generator_.Constant(b.Constant(f32(42)));
     generator_.Constant(b.Constant(f32(-1)));
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -51,7 +51,7 @@
     EXPECT_INST("%float_n1 = OpConstant %float -1");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_F16) {
+TEST_F(SpirvWriterTest, Constant_F16) {
     generator_.Constant(b.Constant(f16(42)));
     generator_.Constant(b.Constant(f16(-1)));
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -59,7 +59,7 @@
     EXPECT_INST("%half_n0x1p_0 = OpConstant %half -0x1p+0");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Vec4Bool) {
+TEST_F(SpirvWriterTest, Constant_Vec4Bool) {
     auto const_bool = [&](bool val) { return mod.constant_values.Get(val); };
     auto* v = mod.constant_values.Composite(
         ty.vec4(ty.bool_()),
@@ -70,7 +70,7 @@
     EXPECT_INST("%1 = OpConstantComposite %v4bool %true %false %false %true");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Vec2i) {
+TEST_F(SpirvWriterTest, Constant_Vec2i) {
     auto const_i32 = [&](float val) { return mod.constant_values.Get(i32(val)); };
     auto* v = mod.constant_values.Composite(ty.vec2(ty.i32()),
                                             utils::Vector{const_i32(42), const_i32(-1)});
@@ -79,7 +79,7 @@
     EXPECT_INST("%1 = OpConstantComposite %v2int %int_42 %int_n1");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Vec3u) {
+TEST_F(SpirvWriterTest, Constant_Vec3u) {
     auto const_u32 = [&](float val) { return mod.constant_values.Get(u32(val)); };
     auto* v = mod.constant_values.Composite(
         ty.vec3(ty.u32()), utils::Vector{const_u32(42), const_u32(0), const_u32(4000000000)});
@@ -88,7 +88,7 @@
     EXPECT_INST("%1 = OpConstantComposite %v3uint %uint_42 %uint_0 %uint_4000000000");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Vec4f) {
+TEST_F(SpirvWriterTest, Constant_Vec4f) {
     auto const_f32 = [&](float val) { return mod.constant_values.Get(f32(val)); };
     auto* v = mod.constant_values.Composite(
         ty.vec4(ty.f32()),
@@ -98,7 +98,7 @@
     EXPECT_INST("%1 = OpConstantComposite %v4float %float_42 %float_0 %float_0_25 %float_n1");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Vec2h) {
+TEST_F(SpirvWriterTest, Constant_Vec2h) {
     auto const_f16 = [&](float val) { return mod.constant_values.Get(f16(val)); };
     auto* v = mod.constant_values.Composite(ty.vec2(ty.f16()),
                                             utils::Vector{const_f16(42), const_f16(0.25)});
@@ -107,7 +107,7 @@
     EXPECT_INST("%1 = OpConstantComposite %v2half %half_0x1_5p_5 %half_0x1pn2");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Mat2x3f) {
+TEST_F(SpirvWriterTest, Constant_Mat2x3f) {
     auto const_f32 = [&](float val) { return mod.constant_values.Get(f32(val)); };
     auto* f32 = ty.f32();
     auto* v = mod.constant_values.Composite(
@@ -133,7 +133,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Mat4x2h) {
+TEST_F(SpirvWriterTest, Constant_Mat4x2h) {
     auto const_f16 = [&](float val) { return mod.constant_values.Get(f16(val)); };
     auto* f16 = ty.f16();
     auto* v = mod.constant_values.Composite(
@@ -165,7 +165,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Array_I32) {
+TEST_F(SpirvWriterTest, Constant_Array_I32) {
     auto* arr =
         mod.constant_values.Composite(ty.array(ty.i32(), 4), utils::Vector{
                                                                  mod.constant_values.Get(1_i),
@@ -178,7 +178,7 @@
     EXPECT_INST("%1 = OpConstantComposite %_arr_int_uint_4 %int_1 %int_2 %int_3 %int_4");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Array_Array_I32) {
+TEST_F(SpirvWriterTest, Constant_Array_Array_I32) {
     auto* inner =
         mod.constant_values.Composite(ty.array(ty.i32(), 4), utils::Vector{
                                                                  mod.constant_values.Get(1_i),
@@ -200,7 +200,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Constant_Struct) {
+TEST_F(SpirvWriterTest, Constant_Struct) {
     auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), {
                                                               {mod.symbols.New("a"), ty.i32()},
                                                               {mod.symbols.New("b"), ty.u32()},
@@ -217,7 +217,7 @@
 }
 
 // Test that we do not emit the same constant more than once.
-TEST_F(SpvGeneratorImplTest, Constant_Deduplicate) {
+TEST_F(SpirvWriterTest, Constant_Deduplicate) {
     generator_.Constant(b.Constant(i32(42)));
     generator_.Constant(b.Constant(i32(42)));
     generator_.Constant(b.Constant(i32(42)));
diff --git a/src/tint/lang/spirv/writer/construct_test.cc b/src/tint/lang/spirv/writer/construct_test.cc
index 763e21d..7f63664 100644
--- a/src/tint/lang/spirv/writer/construct_test.cc
+++ b/src/tint/lang/spirv/writer/construct_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Construct_Vector) {
+TEST_F(SpirvWriterTest, Construct_Vector) {
     auto* func = b.Function("foo", ty.vec4<i32>());
     func->SetParams({
         b.FunctionParam("a", ty.i32()),
@@ -38,7 +38,7 @@
     EXPECT_INST("%result = OpCompositeConstruct %v4int %a %b %c %d");
 }
 
-TEST_F(SpvGeneratorImplTest, Construct_Matrix) {
+TEST_F(SpirvWriterTest, Construct_Matrix) {
     auto* func = b.Function("foo", ty.mat3x4<f32>());
     func->SetParams({
         b.FunctionParam("a", ty.vec4<f32>()),
@@ -55,7 +55,7 @@
     EXPECT_INST("%result = OpCompositeConstruct %mat3v4float %a %b %c");
 }
 
-TEST_F(SpvGeneratorImplTest, Construct_Array) {
+TEST_F(SpirvWriterTest, Construct_Array) {
     auto* func = b.Function("foo", ty.array<f32, 4>());
     func->SetParams({
         b.FunctionParam("a", ty.f32()),
@@ -73,7 +73,7 @@
     EXPECT_INST("%result = OpCompositeConstruct %_arr_float_uint_4 %a %b %c %d");
 }
 
-TEST_F(SpvGeneratorImplTest, Construct_Struct) {
+TEST_F(SpirvWriterTest, Construct_Struct) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.i32()},
@@ -96,7 +96,7 @@
     EXPECT_INST("%result = OpCompositeConstruct %MyStruct %a %b %c");
 }
 
-TEST_F(SpvGeneratorImplTest, Construct_Scalar_Identity) {
+TEST_F(SpirvWriterTest, Construct_Scalar_Identity) {
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({b.FunctionParam("arg", ty.i32())});
     b.With(func->Block(), [&] {
@@ -108,7 +108,7 @@
     EXPECT_INST("OpReturnValue %arg");
 }
 
-TEST_F(SpvGeneratorImplTest, Construct_Vector_Identity) {
+TEST_F(SpirvWriterTest, Construct_Vector_Identity) {
     auto* func = b.Function("foo", ty.vec4<i32>());
     func->SetParams({b.FunctionParam("arg", ty.vec4<i32>())});
     b.With(func->Block(), [&] {
diff --git a/src/tint/lang/spirv/writer/convert_test.cc b/src/tint/lang/spirv/writer/convert_test.cc
index 49c8c4b..16a2e85 100644
--- a/src/tint/lang/spirv/writer/convert_test.cc
+++ b/src/tint/lang/spirv/writer/convert_test.cc
@@ -37,7 +37,7 @@
     return ss.str();
 }
 
-using Convert = SpvGeneratorImplTestWithParam<ConvertCase>;
+using Convert = SpirvWriterTestWithParam<ConvertCase>;
 TEST_P(Convert, Scalar) {
     auto& params = GetParam();
     auto* func = b.Function("foo", MakeScalarType(params.out));
@@ -64,7 +64,7 @@
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%result = " + params.spirv_inst + " %v2" + params.spirv_type_name + " %arg");
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          Convert,
                          testing::Values(
                              // To f32.
@@ -98,7 +98,7 @@
                              ConvertCase{kU32, kBool, "OpINotEqual", "bool"}),
                          PrintCase);
 
-TEST_F(SpvGeneratorImplTest, Convert_Mat2x3_F16_to_F32) {
+TEST_F(SpirvWriterTest, Convert_Mat2x3_F16_to_F32) {
     auto* func = b.Function("foo", ty.mat2x3<f32>());
     func->SetParams({b.FunctionParam("arg", ty.mat2x3<f16>())});
     b.With(func->Block(), [&] {
@@ -117,7 +117,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Convert_Mat4x2_F32_to_F16) {
+TEST_F(SpirvWriterTest, Convert_Mat4x2_F32_to_F16) {
     auto* func = b.Function("foo", ty.mat4x2<f16>());
     func->SetParams({b.FunctionParam("arg", ty.mat4x2<f32>())});
     b.With(func->Block(), [&] {
diff --git a/src/tint/lang/spirv/writer/discard_test.cc b/src/tint/lang/spirv/writer/discard_test.cc
index a571327..bec8940 100644
--- a/src/tint/lang/spirv/writer/discard_test.cc
+++ b/src/tint/lang/spirv/writer/discard_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Discard) {
+TEST_F(SpirvWriterTest, Discard) {
     auto* buffer = b.Var("buffer", ty.ptr<storage, i32>());
     buffer->SetBindingPoint(0, 0);
     b.RootBlock()->Append(buffer);
diff --git a/src/tint/lang/spirv/writer/function_test.cc b/src/tint/lang/spirv/writer/function_test.cc
index a2b1794..7e0dc0c 100644
--- a/src/tint/lang/spirv/writer/function_test.cc
+++ b/src/tint/lang/spirv/writer/function_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Function_Empty) {
+TEST_F(SpirvWriterTest, Function_Empty) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {  //
         b.Return(func);
@@ -36,7 +36,7 @@
 }
 
 // Test that we do not emit the same function type more than once.
-TEST_F(SpvGeneratorImplTest, Function_DeduplicateType) {
+TEST_F(SpirvWriterTest, Function_DeduplicateType) {
     auto* func_a = b.Function("func_a", ty.void_());
     b.With(func_a->Block(), [&] {  //
         b.Return(func_a);
@@ -76,7 +76,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Compute) {
+TEST_F(SpirvWriterTest, Function_EntryPoint_Compute) {
     auto* func =
         b.Function("main", ty.void_(), ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
     b.With(func->Block(), [&] {  //
@@ -103,7 +103,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Fragment) {
+TEST_F(SpirvWriterTest, Function_EntryPoint_Fragment) {
     auto* func = b.Function("main", ty.void_(), ir::Function::PipelineStage::kFragment);
     b.With(func->Block(), [&] {  //
         b.Return(func);
@@ -129,7 +129,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Vertex) {
+TEST_F(SpirvWriterTest, Function_EntryPoint_Vertex) {
     auto* func = b.Function("main", ty.void_(), ir::Function::PipelineStage::kVertex);
     b.With(func->Block(), [&] {  //
         b.Return(func);
@@ -154,7 +154,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Multiple) {
+TEST_F(SpirvWriterTest, Function_EntryPoint_Multiple) {
     auto* f1 = b.Function("main1", ty.void_(), ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
     b.With(f1->Block(), [&] {  //
         b.Return(f1);
@@ -208,7 +208,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_ReturnValue) {
+TEST_F(SpirvWriterTest, Function_ReturnValue) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {  //
         b.Return(func, 42_i);
@@ -229,7 +229,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_Parameters) {
+TEST_F(SpirvWriterTest, Function_Parameters) {
     auto* i32 = ty.i32();
     auto* x = b.FunctionParam("x", i32);
     auto* y = b.FunctionParam("y", i32);
@@ -258,7 +258,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_Call) {
+TEST_F(SpirvWriterTest, Function_Call) {
     auto* i32 = ty.i32();
     auto* x = b.FunctionParam("x", i32);
     auto* y = b.FunctionParam("y", i32);
@@ -281,7 +281,7 @@
     EXPECT_INST("%result = OpFunctionCall %int %foo %int_2 %int_3");
 }
 
-TEST_F(SpvGeneratorImplTest, Function_Call_Void) {
+TEST_F(SpirvWriterTest, Function_Call_Void) {
     auto* foo = b.Function("foo", ty.void_());
     b.With(foo->Block(), [&] {  //
         b.Return(foo);
diff --git a/src/tint/lang/spirv/writer/if_test.cc b/src/tint/lang/spirv/writer/if_test.cc
index 2f36a44..065d1f5 100644
--- a/src/tint/lang/spirv/writer/if_test.cc
+++ b/src/tint/lang/spirv/writer/if_test.cc
@@ -19,7 +19,7 @@
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, If_TrueEmpty_FalseEmpty) {
+TEST_F(SpirvWriterTest, If_TrueEmpty_FalseEmpty) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -42,7 +42,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_FalseEmpty) {
+TEST_F(SpirvWriterTest, If_FalseEmpty) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -69,7 +69,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_TrueEmpty) {
+TEST_F(SpirvWriterTest, If_TrueEmpty) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -96,7 +96,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_BothBranchesReturn) {
+TEST_F(SpirvWriterTest, If_BothBranchesReturn) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -119,7 +119,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue) {
+TEST_F(SpirvWriterTest, If_Phi_SingleValue) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -148,7 +148,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue_TrueReturn) {
+TEST_F(SpirvWriterTest, If_Phi_SingleValue_TrueReturn) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -188,7 +188,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue_FalseReturn) {
+TEST_F(SpirvWriterTest, If_Phi_SingleValue_FalseReturn) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -228,7 +228,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_Phi_MultipleValue_0) {
+TEST_F(SpirvWriterTest, If_Phi_MultipleValue_0) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -258,7 +258,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, If_Phi_MultipleValue_1) {
+TEST_F(SpirvWriterTest, If_Phi_MultipleValue_1) {
     auto* func = b.Function("foo", ty.bool_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
diff --git a/src/tint/lang/spirv/writer/let_test.cc b/src/tint/lang/spirv/writer/let_test.cc
index e01e97c..6b29839 100644
--- a/src/tint/lang/spirv/writer/let_test.cc
+++ b/src/tint/lang/spirv/writer/let_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Let_Constant) {
+TEST_F(SpirvWriterTest, Let_Constant) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         b.Let("l", u32(42));
@@ -32,7 +32,7 @@
     EXPECT_INST("%l = OpConstant %uint 42");
 }
 
-TEST_F(SpvGeneratorImplTest, Let_SharedConstant) {
+TEST_F(SpirvWriterTest, Let_SharedConstant) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         b.Let("l1", u32(42));
diff --git a/src/tint/lang/spirv/writer/loop_test.cc b/src/tint/lang/spirv/writer/loop_test.cc
index 35fdd47..2bbbc09 100644
--- a/src/tint/lang/spirv/writer/loop_test.cc
+++ b/src/tint/lang/spirv/writer/loop_test.cc
@@ -19,7 +19,7 @@
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, Loop_BreakIf) {
+TEST_F(SpirvWriterTest, Loop_BreakIf) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -51,7 +51,7 @@
 }
 
 // Test that we still emit the continuing block with a back-edge, even when it is unreachable.
-TEST_F(SpvGeneratorImplTest, Loop_UnconditionalBreakInBody) {
+TEST_F(SpirvWriterTest, Loop_UnconditionalBreakInBody) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -78,7 +78,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_ConditionalBreakInBody) {
+TEST_F(SpirvWriterTest, Loop_ConditionalBreakInBody) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -121,7 +121,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_ConditionalContinueInBody) {
+TEST_F(SpirvWriterTest, Loop_ConditionalContinueInBody) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -166,7 +166,7 @@
 
 // Test that we still emit the continuing block with a back-edge, and the merge block, even when
 // they are unreachable.
-TEST_F(SpvGeneratorImplTest, Loop_UnconditionalReturnInBody) {
+TEST_F(SpirvWriterTest, Loop_UnconditionalReturnInBody) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -193,7 +193,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_UseResultFromBodyInContinuing) {
+TEST_F(SpirvWriterTest, Loop_UseResultFromBodyInContinuing) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -226,7 +226,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_NestedLoopInBody) {
+TEST_F(SpirvWriterTest, Loop_NestedLoopInBody) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* outer_loop = b.Loop();
@@ -275,7 +275,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_NestedLoopInContinuing) {
+TEST_F(SpirvWriterTest, Loop_NestedLoopInContinuing) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* outer_loop = b.Loop();
@@ -323,7 +323,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_Phi_SingleValue) {
+TEST_F(SpirvWriterTest, Loop_Phi_SingleValue) {
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
@@ -372,7 +372,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Loop_Phi_MultipleValue) {
+TEST_F(SpirvWriterTest, Loop_Phi_MultipleValue) {
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
diff --git a/src/tint/lang/spirv/writer/switch_test.cc b/src/tint/lang/spirv/writer/switch_test.cc
index d427d5a..662fea0 100644
--- a/src/tint/lang/spirv/writer/switch_test.cc
+++ b/src/tint/lang/spirv/writer/switch_test.cc
@@ -19,7 +19,7 @@
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, Switch_Basic) {
+TEST_F(SpirvWriterTest, Switch_Basic) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(42_i);
@@ -45,7 +45,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_MultipleCases) {
+TEST_F(SpirvWriterTest, Switch_MultipleCases) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(42_i);
@@ -85,7 +85,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_MultipleSelectorsPerCase) {
+TEST_F(SpirvWriterTest, Switch_MultipleSelectorsPerCase) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(42_i);
@@ -128,7 +128,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_AllCasesReturn) {
+TEST_F(SpirvWriterTest, Switch_AllCasesReturn) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(42_i);
@@ -168,7 +168,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_ConditionalBreak) {
+TEST_F(SpirvWriterTest, Switch_ConditionalBreak) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(42_i);
@@ -214,7 +214,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_Phi_SingleValue) {
+TEST_F(SpirvWriterTest, Switch_Phi_SingleValue) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* s = b.Switch(42_i);
@@ -249,7 +249,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_Phi_SingleValue_CaseReturn) {
+TEST_F(SpirvWriterTest, Switch_Phi_SingleValue_CaseReturn) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* s = b.Switch(42_i);
@@ -297,7 +297,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_Phi_MultipleValue_0) {
+TEST_F(SpirvWriterTest, Switch_Phi_MultipleValue_0) {
     auto* func = b.Function("foo", ty.i32());
     b.With(func->Block(), [&] {
         auto* s = b.Switch(42_i);
@@ -333,7 +333,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Switch_Phi_MultipleValue_1) {
+TEST_F(SpirvWriterTest, Switch_Phi_MultipleValue_1) {
     auto* func = b.Function("foo", ty.bool_());
     b.With(func->Block(), [&] {
         auto* s = b.Switch(b.Constant(42_i));
diff --git a/src/tint/lang/spirv/writer/swizzle_test.cc b/src/tint/lang/spirv/writer/swizzle_test.cc
index d31be19..ac35ca8 100644
--- a/src/tint/lang/spirv/writer/swizzle_test.cc
+++ b/src/tint/lang/spirv/writer/swizzle_test.cc
@@ -20,7 +20,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, Swizzle_TwoElements) {
+TEST_F(SpirvWriterTest, Swizzle_TwoElements) {
     auto* vec = b.FunctionParam("vec", ty.vec4<i32>());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({vec});
@@ -34,7 +34,7 @@
     EXPECT_INST("%result = OpVectorShuffle %v2int %vec %vec 3 2");
 }
 
-TEST_F(SpvGeneratorImplTest, Swizzle_ThreeElements) {
+TEST_F(SpirvWriterTest, Swizzle_ThreeElements) {
     auto* vec = b.FunctionParam("vec", ty.vec4<i32>());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({vec});
@@ -48,7 +48,7 @@
     EXPECT_INST("%result = OpVectorShuffle %v3int %vec %vec 3 2 1");
 }
 
-TEST_F(SpvGeneratorImplTest, Swizzle_FourElements) {
+TEST_F(SpirvWriterTest, Swizzle_FourElements) {
     auto* vec = b.FunctionParam("vec", ty.vec4<i32>());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({vec});
@@ -62,7 +62,7 @@
     EXPECT_INST("%result = OpVectorShuffle %v4int %vec %vec 3 2 1 0");
 }
 
-TEST_F(SpvGeneratorImplTest, Swizzle_RepeatedElements) {
+TEST_F(SpirvWriterTest, Swizzle_RepeatedElements) {
     auto* vec = b.FunctionParam("vec", ty.vec2<i32>());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({vec});
diff --git a/src/tint/lang/spirv/writer/test_helper.h b/src/tint/lang/spirv/writer/test_helper.h
index 5d82c33..be4f711 100644
--- a/src/tint/lang/spirv/writer/test_helper.h
+++ b/src/tint/lang/spirv/writer/test_helper.h
@@ -64,9 +64,9 @@
 
 /// Base helper class for testing the SPIR-V generator implementation.
 template <typename BASE>
-class SpvGeneratorTestHelperBase : public BASE {
+class SpirvWriterTestHelperBase : public BASE {
   public:
-    SpvGeneratorTestHelperBase() : generator_(&mod, false) {}
+    SpirvWriterTestHelperBase() : generator_(&mod, false) {}
 
     /// The test module.
     ir::Module mod;
@@ -229,10 +229,10 @@
     }
 };
 
-using SpvGeneratorImplTest = SpvGeneratorTestHelperBase<testing::Test>;
+using SpirvWriterTest = SpirvWriterTestHelperBase<testing::Test>;
 
 template <typename T>
-using SpvGeneratorImplTestWithParam = SpvGeneratorTestHelperBase<testing::TestWithParam<T>>;
+using SpirvWriterTestWithParam = SpirvWriterTestHelperBase<testing::TestWithParam<T>>;
 
 }  // namespace tint::writer::spirv
 
diff --git a/src/tint/lang/spirv/writer/texture_builtin_test.cc b/src/tint/lang/spirv/writer/texture_builtin_test.cc
index b29c5d1..af3aff2 100644
--- a/src/tint/lang/spirv/writer/texture_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/texture_builtin_test.cc
@@ -92,7 +92,7 @@
     return ss.str();
 }
 
-class TextureBuiltinTest : public SpvGeneratorImplTestWithParam<TextureBuiltinTestCase> {
+class TextureBuiltinTest : public SpirvWriterTestWithParam<TextureBuiltinTestCase> {
   protected:
     const type::Texture* MakeTextureType(TextureType type,
                                          type::TextureDimension dim,
@@ -204,7 +204,7 @@
     Run(builtin::Function::kTextureSample, kSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSample,
     testing::Values(
         TextureBuiltinTestCase{
@@ -399,7 +399,7 @@
     Run(builtin::Function::kTextureSampleBias, kSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSampleBias,
     testing::Values(
         TextureBuiltinTestCase{
@@ -506,7 +506,7 @@
     Run(builtin::Function::kTextureSampleGrad, kSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSampleGrad,
     testing::Values(
         TextureBuiltinTestCase{
@@ -617,7 +617,7 @@
     Run(builtin::Function::kTextureSampleLevel, kSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSampleLevel,
     testing::Values(
         TextureBuiltinTestCase{
@@ -807,7 +807,7 @@
     Run(builtin::Function::kTextureSampleCompare, kComparisonSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSampleCompare,
     testing::Values(
         TextureBuiltinTestCase{
@@ -892,7 +892,7 @@
     Run(builtin::Function::kTextureSampleCompareLevel, kComparisonSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureSampleCompareLevel,
     testing::Values(
         TextureBuiltinTestCase{
@@ -982,7 +982,7 @@
     Run(builtin::Function::kTextureGather, kSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureGather,
     testing::Values(
         TextureBuiltinTestCase{
@@ -1163,7 +1163,7 @@
     Run(builtin::Function::kTextureGatherCompare, kComparisonSampler);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     TextureGatherCompare,
     testing::Values(
         TextureBuiltinTestCase{
@@ -1247,7 +1247,7 @@
 TEST_P(TextureLoad, Emit) {
     Run(builtin::Function::kTextureLoad, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureLoad,
                          testing::Values(
                              TextureBuiltinTestCase{
@@ -1366,7 +1366,7 @@
 TEST_P(TextureStore, Emit) {
     Run(builtin::Function::kTextureStore, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureStore,
                          testing::Values(
                              TextureBuiltinTestCase{
@@ -1441,7 +1441,7 @@
 TEST_P(TextureDimensions, Emit) {
     Run(builtin::Function::kTextureDimensions, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureDimensions,
                          testing::Values(
                              // 1D implicit Lod.
@@ -1691,7 +1691,7 @@
 TEST_P(TextureNumLayers, Emit) {
     Run(builtin::Function::kTextureNumLayers, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureNumLayers,
                          testing::Values(
                              TextureBuiltinTestCase{
@@ -1758,7 +1758,7 @@
 TEST_P(TextureNumLevels, Emit) {
     Run(builtin::Function::kTextureNumLevels, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureNumLevels,
                          testing::Values(
                              TextureBuiltinTestCase{
@@ -1850,7 +1850,7 @@
 TEST_P(TextureNumSamples, Emit) {
     Run(builtin::Function::kTextureNumSamples, kNoSampler);
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          TextureNumSamples,
                          testing::Values(
                              TextureBuiltinTestCase{
diff --git a/src/tint/lang/spirv/writer/type_test.cc b/src/tint/lang/spirv/writer/type_test.cc
index 530e524..2adf092 100644
--- a/src/tint/lang/spirv/writer/type_test.cc
+++ b/src/tint/lang/spirv/writer/type_test.cc
@@ -29,42 +29,42 @@
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, Type_Void) {
+TEST_F(SpirvWriterTest, Type_Void) {
     generator_.Type(ty.void_());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%void = OpTypeVoid");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Bool) {
+TEST_F(SpirvWriterTest, Type_Bool) {
     generator_.Type(ty.bool_());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%bool = OpTypeBool");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_I32) {
+TEST_F(SpirvWriterTest, Type_I32) {
     generator_.Type(ty.i32());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%int = OpTypeInt 32 1");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_U32) {
+TEST_F(SpirvWriterTest, Type_U32) {
     generator_.Type(ty.u32());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%uint = OpTypeInt 32 0");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_F32) {
+TEST_F(SpirvWriterTest, Type_F32) {
     generator_.Type(ty.f32());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%float = OpTypeFloat 32");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_F16) {
+TEST_F(SpirvWriterTest, Type_F16) {
     generator_.Type(ty.f16());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -75,56 +75,56 @@
     EXPECT_INST("%half = OpTypeFloat 16");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Vec2i) {
+TEST_F(SpirvWriterTest, Type_Vec2i) {
     generator_.Type(ty.vec2<i32>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v2int = OpTypeVector %int 2");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Vec3u) {
+TEST_F(SpirvWriterTest, Type_Vec3u) {
     generator_.Type(ty.vec3<u32>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v3uint = OpTypeVector %uint 3");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Vec4f) {
+TEST_F(SpirvWriterTest, Type_Vec4f) {
     generator_.Type(ty.vec4<f32>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v4float = OpTypeVector %float 4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Vec2h) {
+TEST_F(SpirvWriterTest, Type_Vec2h) {
     generator_.Type(ty.vec2<f16>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v2half = OpTypeVector %half 2");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Vec4Bool) {
+TEST_F(SpirvWriterTest, Type_Vec4Bool) {
     generator_.Type(ty.vec4<bool>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v4bool = OpTypeVector %bool 4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Mat2x3f) {
+TEST_F(SpirvWriterTest, Type_Mat2x3f) {
     generator_.Type(ty.mat2x3(ty.f32()));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%mat2v3float = OpTypeMatrix %v3float 2");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Mat4x2h) {
+TEST_F(SpirvWriterTest, Type_Mat4x2h) {
     generator_.Type(ty.mat4x2(ty.f16()));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%mat4v2half = OpTypeMatrix %v2half 4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Array_DefaultStride) {
+TEST_F(SpirvWriterTest, Type_Array_DefaultStride) {
     generator_.Type(ty.array<f32, 4>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -132,7 +132,7 @@
     EXPECT_INST("%_arr_float_uint_4 = OpTypeArray %float %uint_4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Array_ExplicitStride) {
+TEST_F(SpirvWriterTest, Type_Array_ExplicitStride) {
     generator_.Type(ty.array<f32, 4>(16));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -140,7 +140,7 @@
     EXPECT_INST("%_arr_float_uint_4 = OpTypeArray %float %uint_4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Array_NestedArray) {
+TEST_F(SpirvWriterTest, Type_Array_NestedArray) {
     generator_.Type(ty.array(ty.array<f32, 64u>(), 4u));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -150,7 +150,7 @@
     EXPECT_INST("%_arr__arr_float_uint_64_uint_4 = OpTypeArray %_arr_float_uint_64 %uint_4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_RuntimeArray_DefaultStride) {
+TEST_F(SpirvWriterTest, Type_RuntimeArray_DefaultStride) {
     generator_.Type(ty.array<f32>());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -158,7 +158,7 @@
     EXPECT_INST("%_runtimearr_float = OpTypeRuntimeArray %float");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_RuntimeArray_ExplicitStride) {
+TEST_F(SpirvWriterTest, Type_RuntimeArray_ExplicitStride) {
     generator_.Type(ty.array<f32>(16));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
@@ -166,7 +166,7 @@
     EXPECT_INST("%_runtimearr_float = OpTypeRuntimeArray %float");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Struct) {
+TEST_F(SpirvWriterTest, Type_Struct) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.f32()},
@@ -183,7 +183,7 @@
     EXPECT_INST("%MyStruct = OpTypeStruct %float %v4int");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Struct_MatrixLayout) {
+TEST_F(SpirvWriterTest, Type_Struct_MatrixLayout) {
     auto* str = ty.Struct(
         mod.symbols.New("MyStruct"),
         {
@@ -201,28 +201,28 @@
     EXPECT_INST("%MyStruct = OpTypeStruct %mat3v3float %_arr__arr_mat2v4half_uint_4_uint_4");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Atomic) {
+TEST_F(SpirvWriterTest, Type_Atomic) {
     generator_.Type(ty.atomic(ty.i32()));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%int = OpTypeInt 32 1");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Sampler) {
+TEST_F(SpirvWriterTest, Type_Sampler) {
     generator_.Type(ty.sampler());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%1 = OpTypeSampler");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_SamplerComparison) {
+TEST_F(SpirvWriterTest, Type_SamplerComparison) {
     generator_.Type(ty.comparison_sampler());
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%1 = OpTypeSampler");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_Samplers_Dedup) {
+TEST_F(SpirvWriterTest, Type_Samplers_Dedup) {
     auto id = generator_.Type(ty.sampler());
     EXPECT_EQ(generator_.Type(ty.comparison_sampler()), id);
 
@@ -236,7 +236,7 @@
     TestElementType format = kF32;
 };
 
-using Type_SampledTexture = SpvGeneratorImplTestWithParam<TextureCase>;
+using Type_SampledTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_SampledTexture, Emit) {
     auto params = GetParam();
     generator_.Type(ty.Get<type::SampledTexture>(params.dim, MakeScalarType(params.format)));
@@ -245,7 +245,7 @@
     EXPECT_INST(params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     Type_SampledTexture,
     testing::Values(
         TextureCase{"%1 = OpTypeImage %float 1D 0 0 0 1 Unknown", Dim::k1d, kF32},
@@ -267,7 +267,7 @@
         TextureCase{"%1 = OpTypeImage %uint Cube 0 0 0 1 Unknown", Dim::kCube, kU32},
         TextureCase{"%1 = OpTypeImage %uint Cube 0 1 0 1 Unknown", Dim::kCubeArray, kU32}));
 
-using Type_MultisampledTexture = SpvGeneratorImplTestWithParam<TextureCase>;
+using Type_MultisampledTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_MultisampledTexture, Emit) {
     auto params = GetParam();
     generator_.Type(ty.Get<type::MultisampledTexture>(params.dim, MakeScalarType(params.format)));
@@ -276,13 +276,13 @@
     EXPECT_INST(params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     Type_MultisampledTexture,
     testing::Values(TextureCase{"%1 = OpTypeImage %float 2D 0 0 1 1 Unknown", Dim::k2d, kF32},
                     TextureCase{"%1 = OpTypeImage %int 2D 0 0 1 1 Unknown", Dim::k2d, kI32},
                     TextureCase{"%1 = OpTypeImage %uint 2D 0 0 1 1 Unknown", Dim::k2d, kU32}));
 
-using Type_DepthTexture = SpvGeneratorImplTestWithParam<TextureCase>;
+using Type_DepthTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_DepthTexture, Emit) {
     auto params = GetParam();
     generator_.Type(ty.Get<type::DepthTexture>(params.dim));
@@ -291,14 +291,14 @@
     EXPECT_INST(params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest,
+    SpirvWriterTest,
     Type_DepthTexture,
     testing::Values(TextureCase{"%1 = OpTypeImage %float 2D 0 0 0 1 Unknown", Dim::k2d},
                     TextureCase{"%1 = OpTypeImage %float 2D 0 1 0 1 Unknown", Dim::k2dArray},
                     TextureCase{"%1 = OpTypeImage %float Cube 0 0 0 1 Unknown", Dim::kCube},
                     TextureCase{"%1 = OpTypeImage %float Cube 0 1 0 1 Unknown", Dim::kCubeArray}));
 
-TEST_F(SpvGeneratorImplTest, Type_DepthTexture_DedupWithSampledTexture) {
+TEST_F(SpirvWriterTest, Type_DepthTexture_DedupWithSampledTexture) {
     generator_.Type(ty.Get<type::SampledTexture>(Dim::k2d, ty.f32()));
     generator_.Type(ty.Get<type::DepthTexture>(Dim::k2d));
 
@@ -310,14 +310,14 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_DepthMultiSampledTexture) {
+TEST_F(SpirvWriterTest, Type_DepthMultiSampledTexture) {
     generator_.Type(ty.Get<type::DepthMultisampledTexture>(Dim::k2d));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%1 = OpTypeImage %float 2D 0 0 1 1 Unknown");
 }
 
-TEST_F(SpvGeneratorImplTest, Type_DepthMultisampledTexture_DedupWithMultisampledTexture) {
+TEST_F(SpirvWriterTest, Type_DepthMultisampledTexture_DedupWithMultisampledTexture) {
     generator_.Type(ty.Get<type::MultisampledTexture>(Dim::k2d, ty.f32()));
     generator_.Type(ty.Get<type::DepthMultisampledTexture>(Dim::k2d));
 
@@ -335,7 +335,7 @@
     Dim dim;
     Format format;
 };
-using Type_StorageTexture = SpvGeneratorImplTestWithParam<StorageTextureCase>;
+using Type_StorageTexture = SpirvWriterTestWithParam<StorageTextureCase>;
 TEST_P(Type_StorageTexture, Emit) {
     auto params = GetParam();
     generator_.Type(
@@ -350,7 +350,7 @@
         EXPECT_INST("OpCapability StorageImageExtendedFormats");
     }
 }
-INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest,
+INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
                          Type_StorageTexture,
                          testing::Values(
                              // Test all the dimensions with a single format.
@@ -400,7 +400,7 @@
 
 // Test that we can emit multiple types.
 // Includes types with the same opcode but different parameters.
-TEST_F(SpvGeneratorImplTest, Type_Multiple) {
+TEST_F(SpirvWriterTest, Type_Multiple) {
     generator_.Type(ty.i32());
     generator_.Type(ty.u32());
     generator_.Type(ty.f32());
@@ -416,7 +416,7 @@
 }
 
 // Test that we do not emit the same type more than once.
-TEST_F(SpvGeneratorImplTest, Type_Deduplicate) {
+TEST_F(SpirvWriterTest, Type_Deduplicate) {
     auto id = generator_.Type(ty.i32());
     EXPECT_EQ(generator_.Type(ty.i32()), id);
     EXPECT_EQ(generator_.Type(ty.i32()), id);
diff --git a/src/tint/lang/spirv/writer/unary_test.cc b/src/tint/lang/spirv/writer/unary_test.cc
index ef93dc7..24079ec 100644
--- a/src/tint/lang/spirv/writer/unary_test.cc
+++ b/src/tint/lang/spirv/writer/unary_test.cc
@@ -33,7 +33,7 @@
     std::string spirv_type_name;
 };
 
-using Arithmetic = SpvGeneratorImplTestWithParam<UnaryTestCase>;
+using Arithmetic = SpirvWriterTestWithParam<UnaryTestCase>;
 TEST_P(Arithmetic, Scalar) {
     auto params = GetParam();
 
@@ -65,7 +65,7 @@
     EXPECT_INST("%result = " + params.spirv_inst + " %v2" + params.spirv_type_name + " %arg");
 }
 INSTANTIATE_TEST_SUITE_P(
-    SpvGeneratorImplTest_Unary,
+    SpirvWriterTest_Unary,
     Arithmetic,
     testing::Values(UnaryTestCase{kI32, ir::Unary::Kind::kComplement, "OpNot", "int"},
                     UnaryTestCase{kU32, ir::Unary::Kind::kComplement, "OpNot", "uint"},
diff --git a/src/tint/lang/spirv/writer/var_test.cc b/src/tint/lang/spirv/writer/var_test.cc
index c179959..8a9abf3 100644
--- a/src/tint/lang/spirv/writer/var_test.cc
+++ b/src/tint/lang/spirv/writer/var_test.cc
@@ -22,7 +22,7 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-TEST_F(SpvGeneratorImplTest, FunctionVar_NoInit) {
+TEST_F(SpirvWriterTest, FunctionVar_NoInit) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         b.Var("v", ty.ptr<function, i32>());
@@ -33,7 +33,7 @@
     EXPECT_INST("%v = OpVariable %_ptr_Function_int Function");
 }
 
-TEST_F(SpvGeneratorImplTest, FunctionVar_WithInit) {
+TEST_F(SpirvWriterTest, FunctionVar_WithInit) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* v = b.Var("v", ty.ptr<function, i32>());
@@ -46,7 +46,7 @@
     EXPECT_INST("OpStore %v %int_42");
 }
 
-TEST_F(SpvGeneratorImplTest, FunctionVar_DeclInsideBlock) {
+TEST_F(SpirvWriterTest, FunctionVar_DeclInsideBlock) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* i = b.If(true);
@@ -74,7 +74,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, FunctionVar_Load) {
+TEST_F(SpirvWriterTest, FunctionVar_Load) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* v = b.Var("v", ty.ptr<function, i32>());
@@ -88,7 +88,7 @@
     EXPECT_INST("%result = OpLoad %int %v");
 }
 
-TEST_F(SpvGeneratorImplTest, FunctionVar_Store) {
+TEST_F(SpirvWriterTest, FunctionVar_Store) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* v = b.Var("v", ty.ptr<function, i32>());
@@ -101,14 +101,14 @@
     EXPECT_INST("OpStore %v %int_42");
 }
 
-TEST_F(SpvGeneratorImplTest, PrivateVar_NoInit) {
+TEST_F(SpirvWriterTest, PrivateVar_NoInit) {
     b.RootBlock()->Append(b.Var("v", ty.ptr<private_, i32>()));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v = OpVariable %_ptr_Private_int Private");
 }
 
-TEST_F(SpvGeneratorImplTest, PrivateVar_WithInit) {
+TEST_F(SpirvWriterTest, PrivateVar_WithInit) {
     auto* v = b.Var("v", ty.ptr<private_, i32>());
     v->SetInitializer(b.Constant(42_i));
     b.RootBlock()->Append(v);
@@ -117,7 +117,7 @@
     EXPECT_INST("%v = OpVariable %_ptr_Private_int Private %int_42");
 }
 
-TEST_F(SpvGeneratorImplTest, PrivateVar_LoadAndStore) {
+TEST_F(SpirvWriterTest, PrivateVar_LoadAndStore) {
     auto* v = b.Var("v", ty.ptr<private_, i32>());
     v->SetInitializer(b.Constant(42_i));
     b.RootBlock()->Append(v);
@@ -138,14 +138,14 @@
     EXPECT_INST("OpStore %v %add");
 }
 
-TEST_F(SpvGeneratorImplTest, WorkgroupVar) {
+TEST_F(SpirvWriterTest, WorkgroupVar) {
     b.RootBlock()->Append(b.Var("v", ty.ptr<workgroup, i32>()));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%v = OpVariable %_ptr_Workgroup_int Workgroup");
 }
 
-TEST_F(SpvGeneratorImplTest, WorkgroupVar_LoadAndStore) {
+TEST_F(SpirvWriterTest, WorkgroupVar_LoadAndStore) {
     auto* v = b.RootBlock()->Append(b.Var("v", ty.ptr<workgroup, i32>()));
 
     auto* func = b.Function("foo", ty.void_(), ir::Function::PipelineStage::kCompute,
@@ -165,7 +165,7 @@
     EXPECT_INST("OpStore %v %add");
 }
 
-TEST_F(SpvGeneratorImplTest, WorkgroupVar_ZeroInitializeWithExtension) {
+TEST_F(SpirvWriterTest, WorkgroupVar_ZeroInitializeWithExtension) {
     b.RootBlock()->Append(b.Var("v", ty.ptr<workgroup, i32>()));
 
     // Create a generator with the zero_init_workgroup_memory flag set to `true`.
@@ -175,7 +175,7 @@
     EXPECT_INST("%v = OpVariable %_ptr_Workgroup_int Workgroup %4");
 }
 
-TEST_F(SpvGeneratorImplTest, StorageVar) {
+TEST_F(SpirvWriterTest, StorageVar) {
     auto* v = b.Var("v", ty.ptr<storage, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
@@ -193,7 +193,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, StorageVar_LoadAndStore) {
+TEST_F(SpirvWriterTest, StorageVar_LoadAndStore) {
     auto* v = b.Var("v", ty.ptr<storage, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
@@ -219,7 +219,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, UniformVar) {
+TEST_F(SpirvWriterTest, UniformVar) {
     auto* v = b.Var("v", ty.ptr<uniform, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
@@ -237,7 +237,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, UniformVar_Load) {
+TEST_F(SpirvWriterTest, UniformVar_Load) {
     auto* v = b.Var("v", ty.ptr<uniform, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
@@ -257,7 +257,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, SamplerVar) {
+TEST_F(SpirvWriterTest, SamplerVar) {
     auto* v =
         b.Var("v", ty.ptr(builtin::AddressSpace::kHandle, ty.sampler(), builtin::Access::kRead));
     v->SetBindingPoint(0, 0);
@@ -275,7 +275,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, SamplerVar_Load) {
+TEST_F(SpirvWriterTest, SamplerVar_Load) {
     auto* v =
         b.Var("v", ty.ptr(builtin::AddressSpace::kHandle, ty.sampler(), builtin::Access::kRead));
     v->SetBindingPoint(0, 0);
@@ -292,7 +292,7 @@
     EXPECT_INST("%load = OpLoad %3 %v");
 }
 
-TEST_F(SpvGeneratorImplTest, TextureVar) {
+TEST_F(SpirvWriterTest, TextureVar) {
     auto* v = b.Var("v", ty.ptr(builtin::AddressSpace::kHandle,
                                 ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()),
                                 builtin::Access::kRead));
@@ -311,7 +311,7 @@
 )");
 }
 
-TEST_F(SpvGeneratorImplTest, TextureVar_Load) {
+TEST_F(SpirvWriterTest, TextureVar_Load) {
     auto* v = b.Var("v", ty.ptr(builtin::AddressSpace::kHandle,
                                 ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()),
                                 builtin::Access::kRead));
diff --git a/src/tint/lang/spirv/writer/writer_test.cc b/src/tint/lang/spirv/writer/writer_test.cc
index 048f047..9a562b5 100644
--- a/src/tint/lang/spirv/writer/writer_test.cc
+++ b/src/tint/lang/spirv/writer/writer_test.cc
@@ -21,7 +21,7 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-TEST_F(SpvGeneratorImplTest, ModuleHeader) {
+TEST_F(SpirvWriterTest, ModuleHeader) {
     ASSERT_TRUE(generator_.Generate()) << generator_.Diagnostics().str();
     auto got = Disassemble(generator_.Result());
     EXPECT_THAT(got, testing::StartsWith(R"(OpCapability Shader
@@ -29,7 +29,7 @@
 )"));
 }
 
-TEST_F(SpvGeneratorImplTest, Unreachable) {
+TEST_F(SpirvWriterTest, Unreachable) {
     auto* func = b.Function("foo", ty.void_());
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();