diff --git a/src/writer/hlsl/generator.cc b/src/writer/hlsl/generator.cc
index d521533..06d179e 100644
--- a/src/writer/hlsl/generator.cc
+++ b/src/writer/hlsl/generator.cc
@@ -22,14 +22,16 @@
 
 Generator::Generator(ast::Module module)
     : Text(std::move(module)),
-      impl_(std::make_unique<GeneratorImpl>(&module_)) {}
+      namer_(std::make_unique<UnsafeNamer>(&module)),
+      impl_(std::make_unique<GeneratorImpl>(&module_, namer_.get())) {}
 
 Generator::~Generator() = default;
 
 void Generator::Reset() {
   set_error("");
   out_ = std::ostringstream();
-  impl_ = std::make_unique<GeneratorImpl>(&module_);
+  namer_->Reset();
+  impl_ = std::make_unique<GeneratorImpl>(&module_, namer_.get());
 }
 
 bool Generator::Generate() {
diff --git a/src/writer/hlsl/generator.h b/src/writer/hlsl/generator.h
index 83f6d27..ccbdb08 100644
--- a/src/writer/hlsl/generator.h
+++ b/src/writer/hlsl/generator.h
@@ -19,6 +19,7 @@
 #include <sstream>
 #include <string>
 
+#include "src/namer.h"
 #include "src/writer/hlsl/generator_impl.h"
 #include "src/writer/text.h"
 
@@ -56,6 +57,7 @@
 
  private:
   std::ostringstream out_;
+  std::unique_ptr<Namer> namer_;
   std::unique_ptr<GeneratorImpl> impl_;
 };
 
diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index 1da0158..796d3ec 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -126,8 +126,8 @@
 
 }  // namespace
 
-GeneratorImpl::GeneratorImpl(ast::Module* module)
-    : module_(module), namer_(std::make_unique<UnsafeNamer>(module)) {}
+GeneratorImpl::GeneratorImpl(ast::Module* module, Namer* namer)
+    : module_(module), namer_(namer) {}
 
 GeneratorImpl::~GeneratorImpl() = default;
 
@@ -194,25 +194,25 @@
   global_variables_.set(global->symbol(), global);
 }
 
-std::string GeneratorImpl::current_ep_var_name(VarType type) {
-  std::string name = "";
+Symbol GeneratorImpl::current_ep_var_symbol(VarType type) {
+  Symbol sym;
   switch (type) {
     case VarType::kIn: {
       auto in_it = ep_sym_to_in_data_.find(current_ep_sym_.value());
       if (in_it != ep_sym_to_in_data_.end()) {
-        name = in_it->second.var_name;
+        sym = in_it->second.var_symbol;
       }
       break;
     }
     case VarType::kOut: {
       auto outit = ep_sym_to_out_data_.find(current_ep_sym_.value());
       if (outit != ep_sym_to_out_data_.end()) {
-        name = outit->second.var_name;
+        sym = outit->second.var_symbol;
       }
       break;
     }
   }
-  return name;
+  return sym;
 }
 
 bool GeneratorImpl::EmitConstructedType(std::ostream& out,
@@ -223,7 +223,7 @@
     // HLSL typedef is for intrinsic types only. For an alias'd struct,
     // generate a secondary struct with the new name.
     if (auto* str = alias->type()->As<ast::type::Struct>()) {
-      if (!EmitStructType(out, str, namer_->NameFor(alias->symbol()))) {
+      if (!EmitStructType(out, str, alias->symbol())) {
         return false;
       }
       return true;
@@ -234,7 +234,7 @@
     }
     out << " " << namer_->NameFor(alias->symbol()) << ";" << std::endl;
   } else if (auto* str = ty->As<ast::type::Struct>()) {
-    if (!EmitStructType(out, str, namer_->NameFor(str->symbol()))) {
+    if (!EmitStructType(out, str, str->symbol())) {
       return false;
     }
   } else {
@@ -669,12 +669,12 @@
     return true;
   }
 
-  auto name = namer_->NameFor(ident->symbol());
-  auto caller_sym = ident->symbol();
-  auto it = ep_func_name_remapped_.find(current_ep_sym_.to_str() + "_" +
-                                        caller_sym.to_str());
+  auto func_name_sym = ident->symbol();
+  auto it =
+      ep_func_name_remapped_.find(module_->SymbolToName(current_ep_sym_) + "_" +
+                                  module_->SymbolToName(func_name_sym));
   if (it != ep_func_name_remapped_.end()) {
-    name = it->second;
+    func_name_sym = it->second;
   }
 
   auto* func = module_->FindFunctionBySymbol(ident->symbol());
@@ -684,24 +684,24 @@
     return false;
   }
 
-  out << name << "(";
+  out << namer_->NameFor(func_name_sym) << "(";
 
   bool first = true;
   if (has_referenced_in_var_needing_struct(func)) {
-    auto var_name = current_ep_var_name(VarType::kIn);
-    if (!var_name.empty()) {
-      out << var_name;
+    auto var_sym = current_ep_var_symbol(VarType::kIn);
+    if (var_sym.IsValid()) {
+      out << namer_->NameFor(var_sym);
       first = false;
     }
   }
   if (has_referenced_out_var_needing_struct(func)) {
-    auto var_name = current_ep_var_name(VarType::kOut);
-    if (!var_name.empty()) {
+    auto var_sym = current_ep_var_symbol(VarType::kOut);
+    if (var_sym.IsValid()) {
       if (!first) {
         out << ", ";
       }
       first = false;
-      out << var_name;
+      out << namer_->NameFor(var_sym);
     }
   }
 
@@ -1059,15 +1059,21 @@
       auto var_type = var->storage_class() == ast::StorageClass::kInput
                           ? VarType::kIn
                           : VarType::kOut;
-      auto name = current_ep_var_name(var_type);
-      if (name.empty()) {
+      auto sym = current_ep_var_symbol(var_type);
+      if (!sym.IsValid()) {
         error_ = "unable to find entry point data for variable";
         return false;
       }
-      out << name << ".";
+      out << namer_->NameFor(sym) << ".";
     }
   }
-  out << namer_->NameFor(ident->symbol());
+
+  // Swizzle outputs the name directly
+  if (ident->IsSwizzle()) {
+    out << module_->SymbolToName(ident->symbol());
+  } else {
+    out << namer_->NameFor(ident->symbol());
+  }
 
   return true;
 }
@@ -1216,25 +1222,22 @@
                                          ast::Function* func,
                                          bool emit_duplicate_functions,
                                          Symbol ep_sym) {
-  auto name = func->symbol().to_str();
-
   if (!EmitType(out, func->return_type(), Symbol())) {
     return false;
   }
 
   out << " ";
 
+  auto func_name_sym = func->symbol();
   if (emit_duplicate_functions) {
-    auto func_name = name;
-    auto ep_name = ep_sym.to_str();
-    name = namer_->GenerateName(namer_->NameFor(func->symbol()) + "_" +
-                                namer_->NameFor(ep_sym));
-    ep_func_name_remapped_[ep_name + "_" + func_name] = name;
-  } else {
-    name = namer_->NameFor(func->symbol());
+    auto func_name = module_->SymbolToName(func_name_sym);
+    auto ep_name = module_->SymbolToName(ep_sym);
+    func_name_sym = module_->RegisterSymbol(
+        namer_->GenerateName(func_name + "_" + ep_name));
+    ep_func_name_remapped_[ep_name + "_" + func_name] = func_name_sym;
   }
 
-  out << name << "(";
+  out << namer_->NameFor(func_name_sym) << "(";
 
   bool first = true;
 
@@ -1245,8 +1248,8 @@
   if (emit_duplicate_functions) {
     auto in_it = ep_sym_to_in_data_.find(ep_sym.value());
     if (in_it != ep_sym_to_in_data_.end()) {
-      out << "in " << in_it->second.struct_name << " "
-          << in_it->second.var_name;
+      out << "in " << namer_->NameFor(in_it->second.struct_symbol) << " "
+          << namer_->NameFor(in_it->second.var_symbol);
       first = false;
     }
 
@@ -1255,8 +1258,8 @@
       if (!first) {
         out << ", ";
       }
-      out << "out " << outit->second.struct_name << " "
-          << outit->second.var_name;
+      out << "out " << namer_->NameFor(outit->second.struct_symbol) << " "
+          << namer_->NameFor(outit->second.var_symbol);
       first = false;
     }
   }
@@ -1400,13 +1403,14 @@
   }
 
   if (!in_variables.empty()) {
-    auto in_struct_name = namer_->GenerateName(namer_->NameFor(func->symbol()) +
-                                               "_" + kInStructNameSuffix);
+    auto in_struct_sym = module_->RegisterSymbol(namer_->GenerateName(
+        module_->SymbolToName(func->symbol()) + "_" + kInStructNameSuffix));
     auto in_var_name = namer_->GenerateName(kTintStructInVarPrefix);
-    ep_sym_to_in_data_[func->symbol().value()] = {in_struct_name, in_var_name};
+    ep_sym_to_in_data_[func->symbol().value()] = {
+        in_struct_sym, module_->RegisterSymbol(in_var_name)};
 
     make_indent(out);
-    out << "struct " << in_struct_name << " {" << std::endl;
+    out << "struct " << namer_->NameFor(in_struct_sym) << " {" << std::endl;
 
     increment_indent();
 
@@ -1446,13 +1450,14 @@
   }
 
   if (!outvariables.empty()) {
-    auto outstruct_name = namer_->GenerateName(namer_->NameFor(func->symbol()) +
-                                               "_" + kOutStructNameSuffix);
+    auto outstruct_sym = module_->RegisterSymbol(namer_->GenerateName(
+        module_->SymbolToName(func->symbol()) + "_" + kOutStructNameSuffix));
     auto outvar_name = namer_->GenerateName(kTintStructOutVarPrefix);
-    ep_sym_to_out_data_[func->symbol().value()] = {outstruct_name, outvar_name};
+    ep_sym_to_out_data_[func->symbol().value()] = {
+        outstruct_sym, module_->RegisterSymbol(outvar_name)};
 
     make_indent(out);
-    out << "struct " << outstruct_name << " {" << std::endl;
+    out << "struct " << namer_->NameFor(outstruct_sym) << " {" << std::endl;
 
     increment_indent();
     for (auto& data : outvariables) {
@@ -1542,7 +1547,7 @@
   auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value());
   bool has_outdata = outdata != ep_sym_to_out_data_.end();
   if (has_outdata) {
-    out << outdata->second.struct_name;
+    out << namer_->NameFor(outdata->second.struct_symbol);
   } else {
     out << "void";
   }
@@ -1550,7 +1555,8 @@
 
   auto in_data = ep_sym_to_in_data_.find(current_ep_sym_.value());
   if (in_data != ep_sym_to_in_data_.end()) {
-    out << in_data->second.struct_name << " " << in_data->second.var_name;
+    out << namer_->NameFor(in_data->second.struct_symbol) << " "
+        << namer_->NameFor(in_data->second.var_symbol);
   }
   out << ") {" << std::endl;
 
@@ -1558,8 +1564,8 @@
 
   if (has_outdata) {
     make_indent(out);
-    out << outdata->second.struct_name << " " << outdata->second.var_name << ";"
-        << std::endl;
+    out << namer_->NameFor(outdata->second.struct_symbol) << " "
+        << namer_->NameFor(outdata->second.var_symbol) << ";" << std::endl;
   }
 
   generating_entry_point_ = true;
@@ -1986,7 +1992,7 @@
     out << "return";
     auto outdata = ep_sym_to_out_data_.find(current_ep_sym_.value());
     if (outdata != ep_sym_to_out_data_.end()) {
-      out << " " << outdata->second.var_name;
+      out << " " << namer_->NameFor(outdata->second.var_symbol);
     }
   } else if (stmt->has_value()) {
     std::ostringstream pre;
@@ -2205,11 +2211,11 @@
 
 bool GeneratorImpl::EmitStructType(std::ostream& out,
                                    const ast::type::Struct* str,
-                                   const std::string& name) {
+                                   const Symbol& sym) {
   // TODO(dsinclair): Block decoration?
   // if (str->impl()->decoration() != ast::StructDecoration::kNone) {
   // }
-  out << "struct " << name << " {" << std::endl;
+  out << "struct " << namer_->NameFor(sym) << " {" << std::endl;
 
   increment_indent();
   for (auto* mem : str->impl()->members()) {
diff --git a/src/writer/hlsl/generator_impl.h b/src/writer/hlsl/generator_impl.h
index a8ac5d8..0013033 100644
--- a/src/writer/hlsl/generator_impl.h
+++ b/src/writer/hlsl/generator_impl.h
@@ -54,7 +54,8 @@
  public:
   /// Constructor
   /// @param module the module to generate
-  explicit GeneratorImpl(ast::Module* module);
+  /// @param namer the namer to use
+  GeneratorImpl(ast::Module* module, Namer* namer);
   ~GeneratorImpl();
 
   /// Increment the emitter indent level
@@ -295,11 +296,11 @@
   /// Handles generating a structure declaration
   /// @param out the output stream
   /// @param ty the struct to generate
-  /// @param name the struct name
+  /// @param sym the struct symbol
   /// @returns true if the struct is emitted
   bool EmitStructType(std::ostream& out,
                       const ast::type::Struct* ty,
-                      const std::string& name);
+                      const Symbol& sym);
   /// Handles a unary op expression
   /// @param pre the preamble for the expression stream
   /// @param out the output of the expression stream
@@ -382,18 +383,18 @@
   enum class VarType { kIn, kOut };
 
   struct EntryPointData {
-    std::string struct_name;
-    std::string var_name;
+    Symbol struct_symbol;
+    Symbol var_symbol;
   };
 
-  std::string current_ep_var_name(VarType type);
+  Symbol current_ep_var_symbol(VarType type);
   std::string get_buffer_name(ast::Expression* expr);
 
   std::string error_;
   size_t indent_ = 0;
 
   ast::Module* module_ = nullptr;
-  std::unique_ptr<Namer> namer_;
+  Namer* namer_;
   Symbol current_ep_sym_;
   bool generating_entry_point_ = false;
   uint32_t loop_emission_counter_ = 0;
@@ -404,7 +405,7 @@
   // This maps an input of "<entry_point_name>_<function_name>" to a remapped
   // function name. If there is no entry for a given key then function did
   // not need to be remapped for the entry point and can be emitted directly.
-  std::unordered_map<std::string, std::string> ep_func_name_remapped_;
+  std::unordered_map<std::string, Symbol> ep_func_name_remapped_;
 };
 
 }  // namespace hlsl
diff --git a/src/writer/hlsl/generator_impl_alias_type_test.cc b/src/writer/hlsl/generator_impl_alias_type_test.cc
index f8c823b..1dec131 100644
--- a/src/writer/hlsl/generator_impl_alias_type_test.cc
+++ b/src/writer/hlsl/generator_impl_alias_type_test.cc
@@ -30,7 +30,7 @@
   auto* alias = ty.alias("a", ty.f32);
 
   ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error();
-  EXPECT_EQ(result(), R"(typedef float a;
+  EXPECT_EQ(result(), R"(typedef float test_a;
 )");
 }
 
@@ -44,9 +44,9 @@
   auto* alias = ty.alias("B", s);
 
   ASSERT_TRUE(gen.EmitConstructedType(out, alias)) << gen.error();
-  EXPECT_EQ(result(), R"(struct B {
-  float a;
-  int b;
+  EXPECT_EQ(result(), R"(struct test_B {
+  float test_a;
+  int test_b;
 };
 )");
 }
diff --git a/src/writer/hlsl/generator_impl_array_accessor_test.cc b/src/writer/hlsl/generator_impl_array_accessor_test.cc
index fc71b74..3f5dbe3 100644
--- a/src/writer/hlsl/generator_impl_array_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_array_accessor_test.cc
@@ -33,14 +33,14 @@
   auto* expr = IndexAccessor("ary", 5);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "ary[5]");
+  EXPECT_EQ(result(), "test_ary[5]");
 }
 
 TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) {
   auto* expr = IndexAccessor("ary", "idx");
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "ary[idx]");
+  EXPECT_EQ(result(), "test_ary[test_idx]");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_assign_test.cc b/src/writer/hlsl/generator_impl_assign_test.cc
index 549ce5e..4269681 100644
--- a/src/writer/hlsl/generator_impl_assign_test.cc
+++ b/src/writer/hlsl/generator_impl_assign_test.cc
@@ -35,7 +35,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
-  EXPECT_EQ(result(), "  lhs = rhs;\n");
+  EXPECT_EQ(result(), "  test_lhs = test_rhs;\n");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_binary_test.cc b/src/writer/hlsl/generator_impl_binary_test.cc
index 457acde..322c91f 100644
--- a/src/writer/hlsl/generator_impl_binary_test.cc
+++ b/src/writer/hlsl/generator_impl_binary_test.cc
@@ -115,22 +115,23 @@
     HlslGeneratorImplTest,
     HlslBinaryTest,
     testing::Values(
-        BinaryData{"(left & right)", ast::BinaryOp::kAnd},
-        BinaryData{"(left | right)", ast::BinaryOp::kOr},
-        BinaryData{"(left ^ right)", ast::BinaryOp::kXor},
-        BinaryData{"(left == right)", ast::BinaryOp::kEqual},
-        BinaryData{"(left != right)", ast::BinaryOp::kNotEqual},
-        BinaryData{"(left < right)", ast::BinaryOp::kLessThan},
-        BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan},
-        BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual},
-        BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual},
-        BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft},
-        BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight},
-        BinaryData{"(left + right)", ast::BinaryOp::kAdd},
-        BinaryData{"(left - right)", ast::BinaryOp::kSubtract},
-        BinaryData{"(left * right)", ast::BinaryOp::kMultiply},
-        BinaryData{"(left / right)", ast::BinaryOp::kDivide},
-        BinaryData{"(left % right)", ast::BinaryOp::kModulo}));
+        BinaryData{"(test_left & test_right)", ast::BinaryOp::kAnd},
+        BinaryData{"(test_left | test_right)", ast::BinaryOp::kOr},
+        BinaryData{"(test_left ^ test_right)", ast::BinaryOp::kXor},
+        BinaryData{"(test_left == test_right)", ast::BinaryOp::kEqual},
+        BinaryData{"(test_left != test_right)", ast::BinaryOp::kNotEqual},
+        BinaryData{"(test_left < test_right)", ast::BinaryOp::kLessThan},
+        BinaryData{"(test_left > test_right)", ast::BinaryOp::kGreaterThan},
+        BinaryData{"(test_left <= test_right)", ast::BinaryOp::kLessThanEqual},
+        BinaryData{"(test_left >= test_right)",
+                   ast::BinaryOp::kGreaterThanEqual},
+        BinaryData{"(test_left << test_right)", ast::BinaryOp::kShiftLeft},
+        BinaryData{"(test_left >> test_right)", ast::BinaryOp::kShiftRight},
+        BinaryData{"(test_left + test_right)", ast::BinaryOp::kAdd},
+        BinaryData{"(test_left - test_right)", ast::BinaryOp::kSubtract},
+        BinaryData{"(test_left * test_right)", ast::BinaryOp::kMultiply},
+        BinaryData{"(test_left / test_right)", ast::BinaryOp::kDivide},
+        BinaryData{"(test_left % test_right)", ast::BinaryOp::kModulo}));
 
 TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
   auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
@@ -172,7 +173,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "(mat * 1.0f)");
+  EXPECT_EQ(result(), "(test_mat * 1.0f)");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
@@ -187,7 +188,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "(1.0f * mat)");
+  EXPECT_EQ(result(), "(1.0f * test_mat)");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
@@ -202,7 +203,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "mul(mat, float3(1.0f, 1.0f, 1.0f))");
+  EXPECT_EQ(result(), "mul(test_mat, float3(1.0f, 1.0f, 1.0f))");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
@@ -217,7 +218,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "mul(float3(1.0f, 1.0f, 1.0f), mat)");
+  EXPECT_EQ(result(), "mul(float3(1.0f, 1.0f, 1.0f), test_mat)");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
@@ -232,7 +233,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   EXPECT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "mul(mat, mat)");
+  EXPECT_EQ(result(), "mul(test_mat, test_mat)");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
@@ -244,9 +245,9 @@
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
+  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_left;
 if (_tint_tmp) {
-  _tint_tmp = right;
+  _tint_tmp = test_right;
 }
 )");
 }
@@ -265,15 +266,15 @@
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp_0)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
+  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_a;
 if (_tint_tmp) {
-  _tint_tmp = b;
+  _tint_tmp = test_b;
 }
 bool _tint_tmp_0 = (_tint_tmp);
 if (!_tint_tmp_0) {
-  bool _tint_tmp_1 = c;
+  bool _tint_tmp_1 = test_c;
   if (!_tint_tmp_1) {
-    _tint_tmp_1 = d;
+    _tint_tmp_1 = test_d;
   }
   _tint_tmp_0 = (_tint_tmp_1);
 }
@@ -289,9 +290,9 @@
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
   EXPECT_EQ(result(), "(_tint_tmp)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
+  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_left;
 if (!_tint_tmp) {
-  _tint_tmp = right;
+  _tint_tmp = test_right;
 }
 )");
 }
@@ -332,16 +333,16 @@
       });
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
+  EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
 if (_tint_tmp) {
-  _tint_tmp = b;
+  _tint_tmp = test_b;
 }
 if ((_tint_tmp)) {
   return 1;
 } else {
-  bool _tint_tmp_0 = b;
+  bool _tint_tmp_0 = test_b;
   if (!_tint_tmp_0) {
-    _tint_tmp_0 = c;
+    _tint_tmp_0 = test_c;
   }
   if ((_tint_tmp_0)) {
     return 2;
@@ -363,13 +364,13 @@
       create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, a, b), c));
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
+  EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
 if (_tint_tmp) {
-  _tint_tmp = b;
+  _tint_tmp = test_b;
 }
 bool _tint_tmp_0 = (_tint_tmp);
 if (!_tint_tmp_0) {
-  _tint_tmp_0 = c;
+  _tint_tmp_0 = test_c;
 }
 return (_tint_tmp_0);
 )");
@@ -389,15 +390,15 @@
           create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c), d));
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = b;
+  EXPECT_EQ(result(), R"(bool _tint_tmp = test_b;
 if (!_tint_tmp) {
-  _tint_tmp = c;
+  _tint_tmp = test_c;
 }
 bool _tint_tmp_0 = (_tint_tmp);
 if (_tint_tmp_0) {
-  _tint_tmp_0 = d;
+  _tint_tmp_0 = test_d;
 }
-a = (_tint_tmp_0);
+test_a = (_tint_tmp_0);
 )");
 }
 
@@ -418,15 +419,15 @@
   auto* expr = create<ast::VariableDeclStatement>(var);
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = b;
+  EXPECT_EQ(result(), R"(bool _tint_tmp = test_b;
 if (_tint_tmp) {
-  _tint_tmp = c;
+  _tint_tmp = test_c;
 }
 bool _tint_tmp_0 = (_tint_tmp);
 if (!_tint_tmp_0) {
-  _tint_tmp_0 = d;
+  _tint_tmp_0 = test_d;
 }
-bool a = (_tint_tmp_0);
+bool test_a = (_tint_tmp_0);
 )");
 }
 
@@ -444,11 +445,11 @@
           create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, b, c)));
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
+  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = test_a;
 if (_tint_tmp) {
-  bool _tint_tmp_0 = b;
+  bool _tint_tmp_0 = test_b;
   if (!_tint_tmp_0) {
-    _tint_tmp_0 = c;
+    _tint_tmp_0 = test_c;
   }
   _tint_tmp = (_tint_tmp_0);
 }
@@ -478,27 +479,27 @@
   auto* expr = create<ast::CallStatement>(Call("foo", params));
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
+  EXPECT_EQ(result(), R"(bool _tint_tmp = test_a;
 if (_tint_tmp) {
-  _tint_tmp = b;
+  _tint_tmp = test_b;
 }
-bool _tint_tmp_0 = c;
+bool _tint_tmp_0 = test_c;
 if (!_tint_tmp_0) {
-  _tint_tmp_0 = d;
+  _tint_tmp_0 = test_d;
 }
-bool _tint_tmp_1 = a;
+bool _tint_tmp_1 = test_a;
 if (!_tint_tmp_1) {
-  _tint_tmp_1 = c;
+  _tint_tmp_1 = test_c;
 }
 bool _tint_tmp_2 = (_tint_tmp_1);
 if (_tint_tmp_2) {
-  bool _tint_tmp_3 = b;
+  bool _tint_tmp_3 = test_b;
   if (!_tint_tmp_3) {
-    _tint_tmp_3 = d;
+    _tint_tmp_3 = test_d;
   }
   _tint_tmp_2 = (_tint_tmp_3);
 }
-foo((_tint_tmp), (_tint_tmp_0), (_tint_tmp_2));
+test_foo((_tint_tmp), (_tint_tmp_0), (_tint_tmp_2));
 )");
 }
 
diff --git a/src/writer/hlsl/generator_impl_bitcast_test.cc b/src/writer/hlsl/generator_impl_bitcast_test.cc
index c47df56..3862f75 100644
--- a/src/writer/hlsl/generator_impl_bitcast_test.cc
+++ b/src/writer/hlsl/generator_impl_bitcast_test.cc
@@ -34,7 +34,7 @@
   auto* bitcast = create<ast::BitcastExpression>(ty.f32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
-  EXPECT_EQ(result(), "asfloat(id)");
+  EXPECT_EQ(result(), "asfloat(test_id)");
 }
 
 TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
@@ -42,7 +42,7 @@
   auto* bitcast = create<ast::BitcastExpression>(ty.i32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
-  EXPECT_EQ(result(), "asint(id)");
+  EXPECT_EQ(result(), "asint(test_id)");
 }
 
 TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
@@ -50,7 +50,7 @@
   auto* bitcast = create<ast::BitcastExpression>(ty.u32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, bitcast)) << gen.error();
-  EXPECT_EQ(result(), "asuint(id)");
+  EXPECT_EQ(result(), "asuint(test_id)");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_call_test.cc b/src/writer/hlsl/generator_impl_call_test.cc
index c9b40b4..3708d41 100644
--- a/src/writer/hlsl/generator_impl_call_test.cc
+++ b/src/writer/hlsl/generator_impl_call_test.cc
@@ -37,7 +37,7 @@
   mod->AddFunction(func);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_EQ(result(), "my_func()");
+  EXPECT_EQ(result(), "test_my_func()");
 }
 
 TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
@@ -48,7 +48,7 @@
   mod->AddFunction(func);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_EQ(result(), "my_func(param1, param2)");
+  EXPECT_EQ(result(), "test_my_func(test_param1, test_param2)");
 }
 
 TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
@@ -59,7 +59,7 @@
   mod->AddFunction(func);
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitStatement(out, call)) << gen.error();
-  EXPECT_EQ(result(), "  my_func(param1, param2);\n");
+  EXPECT_EQ(result(), "  test_my_func(test_param1, test_param2);\n");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_cast_test.cc b/src/writer/hlsl/generator_impl_cast_test.cc
index 6625755..66831e6 100644
--- a/src/writer/hlsl/generator_impl_cast_test.cc
+++ b/src/writer/hlsl/generator_impl_cast_test.cc
@@ -31,13 +31,13 @@
 TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) {
   auto* cast = Construct<f32>("id");
   ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error();
-  EXPECT_EQ(result(), "float(id)");
+  EXPECT_EQ(result(), "float(test_id)");
 }
 
 TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) {
   auto* cast = vec3<f32>("id");
   ASSERT_TRUE(gen.EmitExpression(pre, out, cast)) << gen.error();
-  EXPECT_EQ(result(), "float3(id)");
+  EXPECT_EQ(result(), "float3(test_id)");
 }
 
 }  // namespace
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 73bd4c4..2f58c8e 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
@@ -76,9 +76,9 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
-  EXPECT_EQ(result(), R"(struct vtx_main_in {
-  float foo : TEXCOORD0;
-  int bar : TEXCOORD1;
+  EXPECT_EQ(result(), R"(struct test_vtx_main_in {
+  float test_foo : TEXCOORD0;
+  int test_bar : TEXCOORD1;
 };
 
 )");
@@ -126,9 +126,9 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
-  EXPECT_EQ(result(), R"(struct vtx_main_out {
-  float foo : TEXCOORD0;
-  int bar : TEXCOORD1;
+  EXPECT_EQ(result(), R"(struct test_vtx_main_out {
+  float test_foo : TEXCOORD0;
+  int test_bar : TEXCOORD1;
 };
 
 )");
@@ -176,9 +176,9 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
-  EXPECT_EQ(result(), R"(struct main_in {
-  float foo : TEXCOORD0;
-  int bar : TEXCOORD1;
+  EXPECT_EQ(result(), R"(struct test_main_in {
+  float test_foo : TEXCOORD0;
+  int test_bar : TEXCOORD1;
 };
 
 )");
@@ -226,9 +226,9 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
-  EXPECT_EQ(result(), R"(struct main_out {
-  float foo : SV_Target0;
-  int bar : SV_Target1;
+  EXPECT_EQ(result(), R"(struct test_main_out {
+  float test_foo : SV_Target0;
+  int test_bar : SV_Target1;
 };
 
 )");
@@ -365,12 +365,12 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.EmitEntryPointData(out, func, globals)) << gen.error();
-  EXPECT_EQ(result(), R"(struct main_in {
-  float4 coord : SV_Position;
+  EXPECT_EQ(result(), R"(struct test_main_in {
+  float4 test_coord : SV_Position;
 };
 
-struct main_out {
-  float depth : SV_Depth;
+struct test_main_out {
+  float test_depth : SV_Depth;
 };
 
 )");
diff --git a/src/writer/hlsl/generator_impl_function_test.cc b/src/writer/hlsl/generator_impl_function_test.cc
index 42b5988..1c7b772 100644
--- a/src/writer/hlsl/generator_impl_function_test.cc
+++ b/src/writer/hlsl/generator_impl_function_test.cc
@@ -63,7 +63,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(  void my_func() {
+  EXPECT_EQ(result(), R"(  void test_my_func() {
     return;
   }
 
@@ -85,7 +85,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(  void my_func(float a, int b) {
+  EXPECT_EQ(result(), R"(  void test_my_func(float test_a, int test_b) {
     return;
   }
 
@@ -124,18 +124,18 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct frag_main_in {
-  float foo : TEXCOORD0;
+  EXPECT_EQ(result(), R"(struct test_frag_main_in {
+  float test_foo : TEXCOORD0;
 };
 
-struct frag_main_out {
-  float bar : SV_Target1;
+struct test_frag_main_out {
+  float test_bar : SV_Target1;
 };
 
-frag_main_out frag_main(frag_main_in tint_in) {
-  frag_main_out tint_out;
-  tint_out.bar = tint_in.foo;
-  return tint_out;
+test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
+  test_frag_main_out test_tint_out;
+  test_tint_out.test_bar = test_tint_in.test_foo;
+  return test_tint_out;
 }
 
 )");
@@ -176,18 +176,18 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct frag_main_in {
-  float4 coord : SV_Position;
+  EXPECT_EQ(result(), R"(struct test_frag_main_in {
+  float4 test_coord : SV_Position;
 };
 
-struct frag_main_out {
-  float depth : SV_Depth;
+struct test_frag_main_out {
+  float test_depth : SV_Depth;
 };
 
-frag_main_out frag_main(frag_main_in tint_in) {
-  frag_main_out tint_out;
-  tint_out.depth = tint_in.coord.x;
-  return tint_out;
+test_frag_main_out test_frag_main(test_frag_main_in test_tint_in) {
+  test_frag_main_out test_tint_out;
+  test_tint_out.test_depth = test_tint_in.test_coord.x;
+  return test_tint_out;
 }
 
 )");
@@ -222,12 +222,12 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) {
-  float4 coord;
+  EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
+  float4 test_coord;
 };
 
-void frag_main() {
-  float v = coord.x;
+void test_frag_main() {
+  float test_v = test_coord.x;
   return;
 }
 
@@ -272,14 +272,14 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct Uniforms {
-  float4 coord;
+  EXPECT_EQ(result(), R"(struct test_Uniforms {
+  float4 test_coord;
 };
 
-ConstantBuffer<Uniforms> uniforms : register(b0);
+ConstantBuffer<test_Uniforms> test_uniforms : register(b0);
 
-void frag_main() {
-  float v = uniforms.coord.x;
+void test_frag_main() {
+  float test_v = test_uniforms.test_coord.x;
   return;
 }
 
@@ -323,10 +323,10 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
+  EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
 
-void frag_main() {
-  float v = asfloat(coord.Load(4));
+void test_frag_main() {
+  float test_v = asfloat(test_coord.Load(4));
   return;
 }
 
@@ -371,10 +371,10 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(ByteAddressBuffer coord : register(u0);
+  EXPECT_EQ(result(), R"(ByteAddressBuffer test_coord : register(u0);
 
-void frag_main() {
-  float v = asfloat(coord.Load(4));
+void test_frag_main() {
+  float test_v = asfloat(test_coord.Load(4));
   return;
 }
 
@@ -416,10 +416,10 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
+  EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
 
-void frag_main() {
-  coord.Store(4, asuint(2.0f));
+void test_frag_main() {
+  test_coord.Store(4, asuint(2.0f));
   return;
 }
 
@@ -480,25 +480,25 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct ep_1_in {
-  float foo : TEXCOORD0;
+  EXPECT_EQ(result(), R"(struct test_ep_1_in {
+  float test_foo : TEXCOORD0;
 };
 
-struct ep_1_out {
-  float bar : SV_Target1;
-  float val : SV_Target0;
+struct test_ep_1_out {
+  float test_bar : SV_Target1;
+  float test_val : SV_Target0;
 };
 
-float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) {
-  tint_out.bar = tint_in.foo;
-  tint_out.val = param;
-  return tint_in.foo;
+float test_sub_func_ep_1(in test_ep_1_in test_tint_in, out test_ep_1_out test_tint_out, float test_param) {
+  test_tint_out.test_bar = test_tint_in.test_foo;
+  test_tint_out.test_val = test_param;
+  return test_tint_in.test_foo;
 }
 
-ep_1_out ep_1(ep_1_in tint_in) {
-  ep_1_out tint_out;
-  tint_out.bar = sub_func_ep_1(tint_in, tint_out, 1.0f);
-  return tint_out;
+test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
+  test_ep_1_out test_tint_out;
+  test_tint_out.test_bar = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
+  return test_tint_out;
 }
 
 )");
@@ -542,18 +542,18 @@
 
   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;
+  EXPECT_EQ(result(), R"(struct test_ep_1_out {
+  float test_depth : SV_Depth;
 };
 
-float sub_func(float param) {
-  return param;
+float test_sub_func(float test_param) {
+  return test_param;
 }
 
-ep_1_out ep_1() {
-  ep_1_out tint_out;
-  tint_out.depth = sub_func(1.0f);
-  return tint_out;
+test_ep_1_out test_ep_1() {
+  test_ep_1_out test_tint_out;
+  test_tint_out.test_depth = test_sub_func(1.0f);
+  return test_tint_out;
 }
 
 )");
@@ -609,23 +609,23 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct ep_1_in {
-  float4 coord : SV_Position;
+  EXPECT_EQ(result(), R"(struct test_ep_1_in {
+  float4 test_coord : SV_Position;
 };
 
-struct ep_1_out {
-  float depth : SV_Depth;
+struct test_ep_1_out {
+  float test_depth : SV_Depth;
 };
 
-float sub_func_ep_1(in ep_1_in tint_in, out ep_1_out tint_out, float param) {
-  tint_out.depth = tint_in.coord.x;
-  return param;
+float test_sub_func_ep_1(in test_ep_1_in test_tint_in, out test_ep_1_out test_tint_out, float test_param) {
+  test_tint_out.test_depth = test_tint_in.test_coord.x;
+  return test_param;
 }
 
-ep_1_out ep_1(ep_1_in tint_in) {
-  ep_1_out tint_out;
-  tint_out.depth = sub_func_ep_1(tint_in, tint_out, 1.0f);
-  return tint_out;
+test_ep_1_out test_ep_1(test_ep_1_in test_tint_in) {
+  test_ep_1_out test_tint_out;
+  test_tint_out.test_depth = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
+  return test_tint_out;
 }
 
 )");
@@ -672,16 +672,16 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(cbuffer cbuffer_coord : register(b0) {
-  float4 coord;
+  EXPECT_EQ(result(), R"(cbuffer cbuffer_test_coord : register(b0) {
+  float4 test_coord;
 };
 
-float sub_func(float param) {
-  return coord.x;
+float test_sub_func(float test_param) {
+  return test_coord.x;
 }
 
-void frag_main() {
-  float v = sub_func(1.0f);
+void test_frag_main() {
+  float test_v = test_sub_func(1.0f);
   return;
 }
 
@@ -730,14 +730,14 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(RWByteAddressBuffer coord : register(u0);
+  EXPECT_EQ(result(), R"(RWByteAddressBuffer test_coord : register(u0);
 
-float sub_func(float param) {
-  return asfloat(coord.Load((4 * 0)));
+float test_sub_func(float test_param) {
+  return asfloat(test_coord.Load((4 * 0)));
 }
 
-void frag_main() {
-  float v = sub_func(1.0f);
+void test_frag_main() {
+  float test_v = test_sub_func(1.0f);
   return;
 }
 
@@ -775,17 +775,17 @@
 
   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;
+  EXPECT_EQ(result(), R"(struct test_ep_1_out {
+  float test_bar : SV_Target1;
 };
 
-ep_1_out ep_1() {
-  ep_1_out tint_out;
-  tint_out.bar = 1.0f;
+test_ep_1_out test_ep_1() {
+  test_ep_1_out test_tint_out;
+  test_tint_out.test_bar = 1.0f;
   if ((1 == 1)) {
-    return tint_out;
+    return test_tint_out;
   }
-  return tint_out;
+  return test_tint_out;
 }
 
 )");
@@ -807,7 +807,7 @@
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"([numthreads(1, 1, 1)]
-void main() {
+void test_main() {
   return;
 }
 
@@ -831,7 +831,7 @@
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
   EXPECT_EQ(result(), R"([numthreads(2, 4, 6)]
-void main() {
+void test_main() {
   return;
 }
 
@@ -852,7 +852,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(  void my_func(float a[5]) {
+  EXPECT_EQ(result(), R"(  void test_my_func(float test_a[5]) {
     return;
   }
 
@@ -930,21 +930,21 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(struct Data {
-  float d;
+  EXPECT_EQ(result(), R"(struct test_Data {
+  float test_d;
 };
 
-RWByteAddressBuffer data : register(u0);
+RWByteAddressBuffer test_data : register(u0);
 
 [numthreads(1, 1, 1)]
-void a() {
-  float v = asfloat(data.Load(0));
+void test_a() {
+  float test_v = asfloat(test_data.Load(0));
   return;
 }
 
 [numthreads(1, 1, 1)]
-void b() {
-  float v = asfloat(data.Load(0));
+void test_b() {
+  float test_v = asfloat(test_data.Load(0));
   return;
 }
 
diff --git a/src/writer/hlsl/generator_impl_identifier_test.cc b/src/writer/hlsl/generator_impl_identifier_test.cc
index 94bbab6..47f84bd 100644
--- a/src/writer/hlsl/generator_impl_identifier_test.cc
+++ b/src/writer/hlsl/generator_impl_identifier_test.cc
@@ -26,7 +26,7 @@
 TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
   auto* i = Expr("foo");
   ASSERT_TRUE(gen.EmitExpression(pre, out, i)) << gen.error();
-  EXPECT_EQ(result(), "foo");
+  EXPECT_EQ(result(), "test_foo");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_if_test.cc b/src/writer/hlsl/generator_impl_if_test.cc
index 3825a10..a1d6980 100644
--- a/src/writer/hlsl/generator_impl_if_test.cc
+++ b/src/writer/hlsl/generator_impl_if_test.cc
@@ -35,7 +35,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
-  EXPECT_EQ(result(), R"(  if (cond) {
+  EXPECT_EQ(result(), R"(  if (test_cond) {
     return;
   }
 )");
@@ -58,10 +58,10 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
-  EXPECT_EQ(result(), R"(  if (cond) {
+  EXPECT_EQ(result(), R"(  if (test_cond) {
     return;
   } else {
-    if (else_cond) {
+    if (test_else_cond) {
       return;
     }
   }
@@ -84,7 +84,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
-  EXPECT_EQ(result(), R"(  if (cond) {
+  EXPECT_EQ(result(), R"(  if (test_cond) {
     return;
   } else {
     return;
@@ -117,10 +117,10 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, i)) << gen.error();
-  EXPECT_EQ(result(), R"(  if (cond) {
+  EXPECT_EQ(result(), R"(  if (test_cond) {
     return;
   } else {
-    if (else_cond) {
+    if (test_else_cond) {
       return;
     } else {
       return;
diff --git a/src/writer/hlsl/generator_impl_import_test.cc b/src/writer/hlsl/generator_impl_import_test.cc
index 04a7785..5fce156 100644
--- a/src/writer/hlsl/generator_impl_import_test.cc
+++ b/src/writer/hlsl/generator_impl_import_test.cc
@@ -198,7 +198,7 @@
   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)"));
+  EXPECT_EQ(result(), std::string("determinant(test_var)"));
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_intrinsic_test.cc b/src/writer/hlsl/generator_impl_intrinsic_test.cc
index 0306eda..b60259e 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_test.cc
@@ -87,7 +87,9 @@
 
   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])");
+  EXPECT_EQ(
+      result(),
+      "  float3x2(test_a * test_b[0], test_a * test_b[1], test_a * test_b[2])");
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Bad_Name) {
@@ -107,7 +109,7 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_EQ(result(), "  dot(param1, param2)");
+  EXPECT_EQ(result(), "  dot(test_param1, test_param2)");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc b/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
index 08e828b..6629410 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
@@ -22,6 +22,7 @@
 #include "src/ast/type/sampled_texture_type.h"
 #include "src/type_determiner.h"
 #include "src/writer/hlsl/generator_impl.h"
+#include "src/writer/test_namer.h"
 
 namespace tint {
 namespace writer {
@@ -33,181 +34,181 @@
   using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload;
   switch (overload) {
     case ValidTextureOverload::kSample1dF32:
-      return R"(texture.Sample(sampler, 1.0f))";
+      return R"(test_texture.Sample(test_sampler, 1.0f))";
     case ValidTextureOverload::kSample1dArrayF32:
-      return R"(texture.Sample(sampler, float2(1.0f, float(2))))";
+      return R"(test_texture.Sample(test_sampler, float2(1.0f, float(2))))";
     case ValidTextureOverload::kSample2dF32:
-      return R"(texture.Sample(sampler, float2(1.0f, 2.0f)))";
+      return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f)))";
     case ValidTextureOverload::kSample2dOffsetF32:
-      return R"(texture.Sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))";
+      return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
     case ValidTextureOverload::kSample2dArrayF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3))))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3))))";
     case ValidTextureOverload::kSample2dArrayOffsetF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
     case ValidTextureOverload::kSample3dF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
     case ValidTextureOverload::kSample3dOffsetF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))";
     case ValidTextureOverload::kSampleCubeF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
     case ValidTextureOverload::kSampleCubeArrayF32:
-      return R"(texture.Sample(sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
+      return R"(test_texture.Sample(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
     case ValidTextureOverload::kSampleDepth2dF32:
-      return R"(texture.Sample(sampler, float2(1.0f, 2.0f)))";
+      return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f)))";
     case ValidTextureOverload::kSampleDepth2dOffsetF32:
-      return R"(texture.Sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))";
+      return R"(test_texture.Sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
     case ValidTextureOverload::kSampleDepth2dArrayF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3))))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3))))";
     case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
     case ValidTextureOverload::kSampleDepthCubeF32:
-      return R"(texture.Sample(sampler, float3(1.0f, 2.0f, 3.0f)))";
+      return R"(test_texture.Sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
     case ValidTextureOverload::kSampleDepthCubeArrayF32:
-      return R"(texture.Sample(sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
+      return R"(test_texture.Sample(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))";
     case ValidTextureOverload::kSampleBias2dF32:
-      return R"(texture.SampleBias(sampler, float2(1.0f, 2.0f), 3.0f))";
+      return R"(test_texture.SampleBias(test_sampler, float2(1.0f, 2.0f), 3.0f))";
     case ValidTextureOverload::kSampleBias2dOffsetF32:
-      return R"(texture.SampleBias(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
+      return R"(test_texture.SampleBias(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
     case ValidTextureOverload::kSampleBias2dArrayF32:
-      return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
+      return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
     case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
-      return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
+      return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
     case ValidTextureOverload::kSampleBias3dF32:
-      return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kSampleBias3dOffsetF32:
-      return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
+      return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
     case ValidTextureOverload::kSampleBiasCubeF32:
-      return R"(texture.SampleBias(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(test_texture.SampleBias(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kSampleBiasCubeArrayF32:
-      return R"(texture.SampleBias(sampler, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))";
+      return R"(test_texture.SampleBias(test_sampler, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))";
     case ValidTextureOverload::kSampleLevel2dF32:
-      return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3.0f))";
+      return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3.0f))";
     case ValidTextureOverload::kSampleLevel2dOffsetF32:
-      return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
+      return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
     case ValidTextureOverload::kSampleLevel2dArrayF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4.0f))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f))";
     case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
     case ValidTextureOverload::kSampleLevel3dF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kSampleLevel3dOffsetF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
     case ValidTextureOverload::kSampleLevelCubeF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kSampleLevelCubeArrayF32:
-      return R"(texture.SampleLevel(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
+      return R"(test_texture.SampleLevel(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
     case ValidTextureOverload::kSampleLevelDepth2dF32:
-      return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3))";
+      return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3))";
     case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
-      return R"(texture.SampleLevel(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
+      return R"(test_texture.SampleLevel(test_sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
     case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4))";
     case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))";
     case ValidTextureOverload::kSampleLevelDepthCubeF32:
-      return R"(texture.SampleLevel(sampler, float3(1.0f, 2.0f, 3.0f), 4))";
+      return R"(test_texture.SampleLevel(test_sampler, float3(1.0f, 2.0f, 3.0f), 4))";
     case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
-      return R"(texture.SampleLevel(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5))";
+      return R"(test_texture.SampleLevel(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5))";
     case ValidTextureOverload::kSampleGrad2dF32:
-      return R"(texture.SampleGrad(sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))";
+      return R"(test_texture.SampleGrad(test_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))";
     case ValidTextureOverload::kSampleGrad2dOffsetF32:
-      return R"(texture.SampleGrad(sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))";
+      return R"(test_texture.SampleGrad(test_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))";
     case ValidTextureOverload::kSampleGrad2dArrayF32:
-      return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))";
+      return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))";
     case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
-      return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))";
+      return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))";
     case ValidTextureOverload::kSampleGrad3dF32:
-      return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
+      return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
     case ValidTextureOverload::kSampleGrad3dOffsetF32:
-      return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))";
+      return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))";
     case ValidTextureOverload::kSampleGradCubeF32:
-      return R"(texture.SampleGrad(sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
+      return R"(test_texture.SampleGrad(test_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
     case ValidTextureOverload::kSampleGradCubeArrayF32:
-      return R"(texture.SampleGrad(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))";
+      return R"(test_texture.SampleGrad(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))";
     case ValidTextureOverload::kSampleGradDepth2dF32:
-      return R"(texture.SampleCmp(sampler, float2(1.0f, 2.0f), 3.0f))";
+      return R"(test_texture.SampleCmp(test_sampler, float2(1.0f, 2.0f), 3.0f))";
     case ValidTextureOverload::kSampleGradDepth2dOffsetF32:
-      return R"(texture.SampleCmp(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
+      return R"(test_texture.SampleCmp(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
     case ValidTextureOverload::kSampleGradDepth2dArrayF32:
-      return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
+      return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))";
     case ValidTextureOverload::kSampleGradDepth2dArrayOffsetF32:
-      return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))";
+      return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))";
     case ValidTextureOverload::kSampleGradDepthCubeF32:
-      return R"(texture.SampleCmp(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(test_texture.SampleCmp(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kSampleGradDepthCubeArrayF32:
-      return R"(texture.SampleCmp(sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
+      return R"(test_texture.SampleCmp(test_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
     case ValidTextureOverload::kLoad1dF32:
-      return R"(texture.Load(int2(1, 0)))";
+      return R"(test_texture.Load(int2(1, 0)))";
     case ValidTextureOverload::kLoad1dU32:
-      return R"(texture.Load(int2(1, 0)))";
+      return R"(test_texture.Load(int2(1, 0)))";
     case ValidTextureOverload::kLoad1dI32:
-      return R"(texture.Load(int2(1, 0)))";
+      return R"(test_texture.Load(int2(1, 0)))";
     case ValidTextureOverload::kLoad1dArrayF32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad1dArrayU32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad1dArrayI32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad2dF32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad2dU32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad2dI32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoad2dLevelF32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoad2dLevelU32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoad2dLevelI32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoad2dArrayF32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad2dArrayU32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad2dArrayI32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad2dArrayLevelF32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoad2dArrayLevelU32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoad2dArrayLevelI32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoad3dF32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad3dU32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad3dI32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoad3dLevelF32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoad3dLevelU32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoad3dLevelI32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoadMultisampled2dF32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoadMultisampled2dU32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoadMultisampled2dI32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoadMultisampled2dArrayF32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoadMultisampled2dArrayU32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoadMultisampled2dArrayI32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoadDepth2dF32:
-      return R"(texture.Load(int3(1, 2, 0)))";
+      return R"(test_texture.Load(int3(1, 2, 0)))";
     case ValidTextureOverload::kLoadDepth2dLevelF32:
-      return R"(texture.Load(int3(1, 2, 0), 3))";
+      return R"(test_texture.Load(int3(1, 2, 0), 3))";
     case ValidTextureOverload::kLoadDepth2dArrayF32:
-      return R"(texture.Load(int4(1, 2, 3, 0)))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0)))";
     case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
-      return R"(texture.Load(int4(1, 2, 3, 0), 4))";
+      return R"(test_texture.Load(int4(1, 2, 3, 0), 4))";
     case ValidTextureOverload::kLoadStorageRO1dRgba32float:
-      return R"(texture.Load(1))";
+      return R"(test_texture.Load(1))";
     case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float:
-      return R"(texture.Load(int2(1, 2)))";
+      return R"(test_texture.Load(int2(1, 2)))";
     case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
     case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
     case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
@@ -224,21 +225,21 @@
     case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
     case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
     case ValidTextureOverload::kLoadStorageRO2dRgba32float:
-      return R"(texture.Load(int2(1, 2)))";
+      return R"(test_texture.Load(int2(1, 2)))";
     case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
-      return R"(texture.Load(int3(1, 2, 3)))";
+      return R"(test_texture.Load(int3(1, 2, 3)))";
     case ValidTextureOverload::kLoadStorageRO3dRgba32float:
-      return R"(texture.Load(int3(1, 2, 3)))";
+      return R"(test_texture.Load(int3(1, 2, 3)))";
     case ValidTextureOverload::kStoreWO1dRgba32float:
-      return R"(texture[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))";
+      return R"(test_texture[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))";
     case ValidTextureOverload::kStoreWO1dArrayRgba32float:
-      return R"(texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
+      return R"(test_texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
     case ValidTextureOverload::kStoreWO2dRgba32float:
-      return R"(texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
+      return R"(test_texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
     case ValidTextureOverload::kStoreWO2dArrayRgba32float:
-      return R"(texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
+      return R"(test_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
     case ValidTextureOverload::kStoreWO3dRgba32float:
-      return R"(texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
+      return R"(test_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
   }
   return "<unmatched texture overload>";
 }  // NOLINT - Ignore the length of this function
@@ -258,8 +259,10 @@
 
   /// The type determiner
   TypeDeterminer td{mod};
+  /// The namer
+  TestNamer namer{mod};
   /// The generator
-  GeneratorImpl gen{mod};
+  GeneratorImpl gen{mod, &namer};
   /// The output stream
   std::ostringstream out;
   /// The pre-output stream
diff --git a/src/writer/hlsl/generator_impl_loop_test.cc b/src/writer/hlsl/generator_impl_loop_test.cc
index 4e7f017..5821c57 100644
--- a/src/writer/hlsl/generator_impl_loop_test.cc
+++ b/src/writer/hlsl/generator_impl_loop_test.cc
@@ -100,7 +100,7 @@
     bool tint_hlsl_is_first_1 = true;
     for(;;) {
       if (!tint_hlsl_is_first_1) {
-        lhs = rhs;
+        test_lhs = test_rhs;
       }
       tint_hlsl_is_first_1 = false;
 
@@ -163,16 +163,16 @@
   ASSERT_TRUE(gen.EmitStatement(out, outer)) << gen.error();
   EXPECT_EQ(result(), R"(  {
     bool tint_hlsl_is_first_1 = true;
-    float lhs;
-    float other;
+    float test_lhs;
+    float test_other;
     for(;;) {
       if (!tint_hlsl_is_first_1) {
-        lhs = rhs;
+        test_lhs = test_rhs;
       }
       tint_hlsl_is_first_1 = false;
 
-      lhs = 2.400000095f;
-      other = 0.0f;
+      test_lhs = 2.400000095f;
+      test_other = 0.0f;
     }
   }
 )");
diff --git a/src/writer/hlsl/generator_impl_member_accessor_test.cc b/src/writer/hlsl/generator_impl_member_accessor_test.cc
index 4b13271..f46c88a 100644
--- a/src/writer/hlsl/generator_impl_member_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_member_accessor_test.cc
@@ -54,7 +54,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "str.mem");
+  EXPECT_EQ(result(), "test_str.test_mem");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -85,7 +85,7 @@
   ASSERT_TRUE(td.DetermineResultType(expr));
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asfloat(data.Load(4))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load(4))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -115,7 +115,7 @@
   ASSERT_TRUE(td.DetermineResultType(expr));
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asint(data.Load(0))");
+  EXPECT_EQ(result(), "asint(test_data.Load(0))");
 }
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
        EmitExpression_MemberAccessor_StorageBuffer_Store_Matrix) {
@@ -156,9 +156,9 @@
   ASSERT_TRUE(td.DetermineResultType(assign));
 
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
-  EXPECT_EQ(result(), R"(float3x2 _tint_tmp = b;
-data.Store3(4 + 0, asuint(_tint_tmp[0]));
-data.Store3(4 + 16, asuint(_tint_tmp[1]));
+  EXPECT_EQ(result(), R"(float3x2 _tint_tmp = test_b;
+test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
+test_data.Store3(4 + 16, asuint(_tint_tmp[1]));
 )");
 }
 
@@ -200,8 +200,8 @@
   EXPECT_EQ(
       result(),
       R"(float3x2 _tint_tmp = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
-data.Store3(4 + 0, asuint(_tint_tmp[0]));
-data.Store3(4 + 16, asuint(_tint_tmp[1]));
+test_data.Store3(4 + 0, asuint(_tint_tmp[0]));
+test_data.Store3(4 + 16, asuint(_tint_tmp[1]));
 )");
 }
 
@@ -236,8 +236,8 @@
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
   EXPECT_EQ(result(),
-            "asfloat(uint2x3(data.Load2(4 + 0), data.Load2(4 + 8), "
-            "data.Load2(4 + 16)))");
+            "asfloat(uint2x3(test_data.Load2(4 + 0), test_data.Load2(4 + 8), "
+            "test_data.Load2(4 + 16)))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -274,8 +274,9 @@
   ASSERT_TRUE(td.DetermineResultType(expr));
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(),
-            "asfloat(uint3x2(data.Load3(4 + 0), data.Load3(4 + 16)))");
+  EXPECT_EQ(
+      result(),
+      "asfloat(uint3x2(test_data.Load3(4 + 0), test_data.Load3(4 + 16)))");
 }
 
 TEST_F(
@@ -307,8 +308,8 @@
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
   EXPECT_EQ(result(),
-            "asfloat(uint3x3(data.Load3(0 + 0), data.Load3(0 + 16), "
-            "data.Load3(0 + 32)))");
+            "asfloat(uint3x3(test_data.Load3(0 + 0), test_data.Load3(0 + 16), "
+            "test_data.Load3(0 + 32)))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -340,7 +341,7 @@
   ASSERT_TRUE(td.DetermineResultType(expr));
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + (16 * 2) + 16))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + (16 * 2) + 16))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -372,7 +373,7 @@
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asint(data.Load((4 * 2) + 0))");
+  EXPECT_EQ(result(), "asint(test_data.Load((4 * 2) + 0))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -405,7 +406,7 @@
   ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asint(data.Load((4 * ((2 + 4) - 3)) + 0))");
+  EXPECT_EQ(result(), "asint(test_data.Load((4 * ((2 + 4) - 3)) + 0))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -439,7 +440,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(assign));
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
-  EXPECT_EQ(result(), R"(data.Store(4, asuint(2.0f));
+  EXPECT_EQ(result(), R"(test_data.Store(4, asuint(2.0f));
 )");
 }
 
@@ -477,7 +478,7 @@
 
   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));
+  EXPECT_EQ(result(), R"(test_data.Store((4 * 2) + 0, asuint(2));
 )");
 }
 
@@ -512,7 +513,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(assign));
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
-  EXPECT_EQ(result(), R"(data.Store(0, asuint(2));
+  EXPECT_EQ(result(), R"(test_data.Store(0, asuint(2));
 )");
 }
 
@@ -545,7 +546,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asfloat(data.Load3(16))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load3(16))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -581,7 +582,7 @@
   ASSERT_TRUE(td.DetermineResultType(assign));
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
   EXPECT_EQ(result(),
-            R"(data.Store3(16, asuint(float3(1.0f, 2.0f, 3.0f)));
+            R"(test_data.Store3(16, asuint(float3(1.0f, 2.0f, 3.0f)));
 )");
 }
 
@@ -631,7 +632,7 @@
 
   ASSERT_TRUE(td.DetermineResultType(expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load3(16 + (32 * 2) + 0))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -679,7 +680,7 @@
 
   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");
+  EXPECT_EQ(result(), "asfloat(test_data.Load3(16 + (32 * 2) + 0)).xy");
 }
 
 TEST_F(
@@ -730,7 +731,7 @@
 
   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))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + 16 + (32 * 2) + 0))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -780,7 +781,7 @@
 
   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))");
+  EXPECT_EQ(result(), "asfloat(test_data.Load((4 * 1) + 16 + (32 * 2) + 0))");
 }
 
 TEST_F(HlslGeneratorImplTest_MemberAccessor,
@@ -832,8 +833,9 @@
 
   ASSERT_TRUE(td.DetermineResultType(assign));
   ASSERT_TRUE(gen.EmitStatement(out, assign)) << gen.error();
-  EXPECT_EQ(result(),
-            R"(data.Store3(16 + (32 * 2) + 0, asuint(float3(1.0f, 2.0f, 3.0f)));
+  EXPECT_EQ(
+      result(),
+      R"(test_data.Store3(16 + (32 * 2) + 0, asuint(float3(1.0f, 2.0f, 3.0f)));
 )");
 }
 
@@ -888,10 +890,34 @@
   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.0f));
+            R"(test_data.Store((4 * 1) + 16 + (32 * 2) + 0, asuint(1.0f));
 )");
 }
 
+TEST_F(HlslGeneratorImplTest_MemberAccessor,
+       EmitExpression_MemberAccessor_Swizzle_xyz) {
+  auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
+  td.RegisterVariableForTesting(vec);
+  mod->AddGlobalVariable(vec);
+
+  auto* expr = MemberAccessor("my_vec", "xyz");
+  ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
+  EXPECT_EQ(result(), "test_my_vec.xyz");
+}
+
+TEST_F(HlslGeneratorImplTest_MemberAccessor,
+       EmitExpression_MemberAccessor_Swizzle_gbr) {
+  auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
+  td.RegisterVariableForTesting(vec);
+  mod->AddGlobalVariable(vec);
+
+  auto* expr = MemberAccessor("my_vec", "gbr");
+  ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
+  ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
+  EXPECT_EQ(result(), "test_my_vec.gbr");
+}
+
 }  // namespace
 }  // namespace hlsl
 }  // namespace writer
diff --git a/src/writer/hlsl/generator_impl_module_constant_test.cc b/src/writer/hlsl/generator_impl_module_constant_test.cc
index 171942f..28f4c58 100644
--- a/src/writer/hlsl/generator_impl_module_constant_test.cc
+++ b/src/writer/hlsl/generator_impl_module_constant_test.cc
@@ -38,7 +38,7 @@
             array<f32, 3>(1.f, 2.f, 3.f), ast::VariableDecorationList{});
 
   ASSERT_TRUE(gen.EmitProgramConstVariable(out, var)) << gen.error();
-  EXPECT_EQ(result(), "static const float pos[3] = {1.0f, 2.0f, 3.0f};\n");
+  EXPECT_EQ(result(), "static const float test_pos[3] = {1.0f, 2.0f, 3.0f};\n");
 }
 
 TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
@@ -51,7 +51,7 @@
   EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
 #define WGSL_SPEC_CONSTANT_23 3.0f
 #endif
-static const float pos = WGSL_SPEC_CONSTANT_23;
+static const float test_pos = WGSL_SPEC_CONSTANT_23;
 #undef WGSL_SPEC_CONSTANT_23
 )");
 }
@@ -66,7 +66,7 @@
   EXPECT_EQ(result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
 #error spec constant required for constant id 23
 #endif
-static const float pos = WGSL_SPEC_CONSTANT_23;
+static const float test_pos = WGSL_SPEC_CONSTANT_23;
 #undef WGSL_SPEC_CONSTANT_23
 )");
 }
diff --git a/src/writer/hlsl/generator_impl_return_test.cc b/src/writer/hlsl/generator_impl_return_test.cc
index 92939e4..b3bbf34 100644
--- a/src/writer/hlsl/generator_impl_return_test.cc
+++ b/src/writer/hlsl/generator_impl_return_test.cc
@@ -40,7 +40,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, r)) << gen.error();
-  EXPECT_EQ(result(), "  return expr;\n");
+  EXPECT_EQ(result(), "  return test_expr;\n");
 }
 
 }  // namespace
diff --git a/src/writer/hlsl/generator_impl_switch_test.cc b/src/writer/hlsl/generator_impl_switch_test.cc
index 9a73bce..7cd65cc 100644
--- a/src/writer/hlsl/generator_impl_switch_test.cc
+++ b/src/writer/hlsl/generator_impl_switch_test.cc
@@ -54,7 +54,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, s)) << gen.error();
-  EXPECT_EQ(result(), R"(  switch(cond) {
+  EXPECT_EQ(result(), R"(  switch(test_cond) {
     case 5: {
       break;
     }
diff --git a/src/writer/hlsl/generator_impl_test.cc b/src/writer/hlsl/generator_impl_test.cc
index 75980eb..7f0766b 100644
--- a/src/writer/hlsl/generator_impl_test.cc
+++ b/src/writer/hlsl/generator_impl_test.cc
@@ -33,7 +33,7 @@
   mod->AddFunction(func);
 
   ASSERT_TRUE(gen.Generate(out)) << gen.error();
-  EXPECT_EQ(result(), R"(void my_func() {
+  EXPECT_EQ(result(), R"(void test_my_func() {
 }
 
 )");
diff --git a/src/writer/hlsl/generator_impl_type_test.cc b/src/writer/hlsl/generator_impl_type_test.cc
index ef697cd..998d082 100644
--- a/src/writer/hlsl/generator_impl_type_test.cc
+++ b/src/writer/hlsl/generator_impl_type_test.cc
@@ -47,20 +47,20 @@
   auto* alias = ty.alias("alias", ty.f32);
 
   ASSERT_TRUE(gen.EmitType(out, alias, Symbol())) << gen.error();
-  EXPECT_EQ(result(), "alias");
+  EXPECT_EQ(result(), "test_alias");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) {
   auto sym = mod->RegisterSymbol("ary");
   ASSERT_TRUE(gen.EmitType(out, ty.array<bool, 4>(), sym)) << gen.error();
-  EXPECT_EQ(result(), "bool ary[4]");
+  EXPECT_EQ(result(), "bool test_ary[4]");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) {
   auto* arr = ty.array(ty.array<bool, 4>(), 5);
   auto sym = mod->RegisterSymbol("ary");
   ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
-  EXPECT_EQ(result(), "bool ary[5][4]");
+  EXPECT_EQ(result(), "bool test_ary[5][4]");
 }
 
 // TODO(dsinclair): Is this possible? What order should it output in?
@@ -69,14 +69,14 @@
   auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 0);
   auto sym = mod->RegisterSymbol("ary");
   ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
-  EXPECT_EQ(result(), "bool ary[5][4][1]");
+  EXPECT_EQ(result(), "bool test_ary[5][4][1]");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) {
   auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 6);
   auto sym = mod->RegisterSymbol("ary");
   ASSERT_TRUE(gen.EmitType(out, arr, sym)) << gen.error();
-  EXPECT_EQ(result(), "bool ary[6][5][4]");
+  EXPECT_EQ(result(), "bool test_ary[6][5][4]");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, EmitType_Array_WithoutName) {
@@ -125,10 +125,11 @@
       ast::StructDecorationList{});
 
   auto* s = ty.struct_("S", str);
-  ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error();
-  EXPECT_EQ(result(), R"(struct S {
-  int a;
-  float b;
+  ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
+      << gen.error();
+  EXPECT_EQ(result(), R"(struct test_S {
+  int test_a;
+  float test_b;
 };
 )");
 }
@@ -140,8 +141,8 @@
       ast::StructDecorationList{});
 
   auto* s = ty.struct_("S", str);
-  ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error();
-  EXPECT_EQ(result(), "S");
+  ASSERT_TRUE(gen.EmitType(out, s, mod->RegisterSymbol("S"))) << gen.error();
+  EXPECT_EQ(result(), "test_S");
 }
 
 TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_InjectPadding) {
@@ -153,13 +154,13 @@
 
   auto* s = ty.struct_("S", str);
   ASSERT_TRUE(gen.EmitType(out, s, Symbol())) << gen.error();
-  EXPECT_EQ(result(), R"(struct {
+  EXPECT_EQ(result(), R"(struct test_S {
   int8_t pad_0[4];
-  int a;
+  int test_a;
   int8_t pad_1[24];
-  float b;
+  float test_b;
   int8_t pad_2[92];
-  float c;
+  float test_c;
 })");
 }
 
@@ -169,10 +170,11 @@
       ast::StructDecorationList{});
 
   auto* s = ty.struct_("S", str);
-  ASSERT_TRUE(gen.EmitStructType(out, s, "S")) << gen.error();
-  EXPECT_EQ(result(), R"(struct S {
-  int double;
-  float float;
+  ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("S")))
+      << gen.error();
+  EXPECT_EQ(result(), R"(struct test_S {
+  int test_double;
+  float test_float;
 };
 )");
 }
@@ -188,10 +190,11 @@
       decos);
 
   auto* s = ty.struct_("S", str);
-  ASSERT_TRUE(gen.EmitStructType(out, s, "B")) << gen.error();
-  EXPECT_EQ(result(), R"(struct B {
-  int a;
-  float b;
+  ASSERT_TRUE(gen.EmitStructType(out, s, mod->RegisterSymbol("B")))
+      << gen.error();
+  EXPECT_EQ(result(), R"(struct test_B {
+  int test_a;
+  float test_b;
 })");
 }
 
diff --git a/src/writer/hlsl/generator_impl_unary_op_test.cc b/src/writer/hlsl/generator_impl_unary_op_test.cc
index 77fdf7a..b9b1ed1 100644
--- a/src/writer/hlsl/generator_impl_unary_op_test.cc
+++ b/src/writer/hlsl/generator_impl_unary_op_test.cc
@@ -41,7 +41,7 @@
   auto* op = create<ast::UnaryOpExpression>(params.op, expr);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
-  EXPECT_EQ(result(), std::string(params.name) + "(expr)");
+  EXPECT_EQ(result(), std::string(params.name) + "(test_expr)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp,
                          HlslUnaryOpTest,
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 5d5eae9..9facd13 100644
--- a/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
@@ -39,7 +39,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), "  float a;\n");
+  EXPECT_EQ(result(), "  float test_a;\n");
 }
 
 TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) {
@@ -49,7 +49,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), "  const float a;\n");
+  EXPECT_EQ(result(), "  const float test_a;\n");
 }
 
 TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) {
@@ -59,7 +59,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), "  float a[5];\n");
+  EXPECT_EQ(result(), "  float test_a[5];\n");
 }
 
 TEST_F(HlslGeneratorImplTest_VariableDecl,
@@ -70,7 +70,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), "  float a;\n");
+  EXPECT_EQ(result(), "  float test_a;\n");
 }
 
 TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
@@ -80,7 +80,7 @@
   gen.increment_indent();
 
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), "  float a;\n");
+  EXPECT_EQ(result(), "  float test_a;\n");
 }
 
 TEST_F(HlslGeneratorImplTest_VariableDecl,
@@ -90,7 +90,7 @@
 
   auto* stmt = create<ast::VariableDeclStatement>(var);
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), R"(float a = initializer;
+  EXPECT_EQ(result(), R"(float test_a = test_initializer;
 )");
 }
 
@@ -101,7 +101,7 @@
 
   auto* stmt = create<ast::VariableDeclStatement>(var);
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
-  EXPECT_EQ(result(), R"(float3 a = float3(0.0f);
+  EXPECT_EQ(result(), R"(float3 test_a = float3(0.0f);
 )");
 }
 
@@ -113,7 +113,7 @@
   auto* stmt = create<ast::VariableDeclStatement>(var);
   ASSERT_TRUE(gen.EmitStatement(out, stmt)) << gen.error();
   EXPECT_EQ(result(),
-            R"(float3x2 a = float3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+            R"(float3x2 test_a = float3x2(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 fd874f4..f04526a 100644
--- a/src/writer/hlsl/test_helper.h
+++ b/src/writer/hlsl/test_helper.h
@@ -24,6 +24,7 @@
 #include "src/ast/builder.h"
 #include "src/type_determiner.h"
 #include "src/writer/hlsl/generator_impl.h"
+#include "src/writer/test_namer.h"
 
 namespace tint {
 namespace writer {
@@ -33,7 +34,7 @@
 template <typename BODY>
 class TestHelperBase : public BODY, public ast::BuilderWithModule {
  public:
-  TestHelperBase() : td(mod), gen(mod) {}
+  TestHelperBase() : td(mod), namer(mod), gen(mod, &namer) {}
   ~TestHelperBase() = default;
 
   /// @returns the result string
@@ -44,6 +45,8 @@
 
   /// The type determiner
   TypeDeterminer td;
+  /// The test namer
+  TestNamer namer;
   /// The generator
   GeneratorImpl gen;