diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index 23172b9..3738d69 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -47,7 +47,7 @@
 const char kOutStructNameSuffix[] = "out";
 const char kTintStructInVarPrefix[] = "tint_in";
 const char kTintStructOutVarPrefix[] = "tint_out";
-const char kTempNamePrefix[] = "_tint_tmp";
+const char kTempNamePrefix[] = "tint_tmp";
 
 bool last_is_break_or_fallthrough(const ast::BlockStatement* stmts) {
   if (stmts->empty()) {
@@ -176,18 +176,7 @@
 }
 
 std::string GeneratorImpl::generate_name(const std::string& prefix) {
-  if (!builder_.Symbols().Get(prefix).IsValid()) {
-    builder_.Symbols().Register(prefix);
-    return prefix;
-  }
-  for (uint32_t i = 0;; i++) {
-    std::string name = prefix + "_" + std::to_string(i);
-    if (builder_.Symbols().Get(name).IsValid()) {
-      continue;
-    }
-    builder_.Symbols().Register(name);
-    return name;
-  }
+  return builder_.Symbols().NameFor(builder_.Symbols().New(prefix));
 }
 
 std::string GeneratorImpl::current_ep_var_name(VarType type) {
diff --git a/src/writer/hlsl/generator_impl_binary_test.cc b/src/writer/hlsl/generator_impl_binary_test.cc
index 1c56bfc..41d1289 100644
--- a/src/writer/hlsl/generator_impl_binary_test.cc
+++ b/src/writer/hlsl/generator_impl_binary_test.cc
@@ -241,10 +241,10 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "(_tint_tmp)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
-if (_tint_tmp) {
-  _tint_tmp = right;
+  EXPECT_EQ(result(), "(tint_tmp)");
+  EXPECT_EQ(pre_result(), R"(bool tint_tmp = left;
+if (tint_tmp) {
+  tint_tmp = right;
 }
 )");
 }
@@ -264,18 +264,18 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "(_tint_tmp_0)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
-if (_tint_tmp) {
-  _tint_tmp = b;
+  EXPECT_EQ(result(), "(tint_tmp_1)");
+  EXPECT_EQ(pre_result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
 }
-bool _tint_tmp_0 = (_tint_tmp);
-if (!_tint_tmp_0) {
-  bool _tint_tmp_1 = c;
-  if (!_tint_tmp_1) {
-    _tint_tmp_1 = d;
+bool tint_tmp_1 = (tint_tmp);
+if (!tint_tmp_1) {
+  bool tint_tmp_2 = c;
+  if (!tint_tmp_2) {
+    tint_tmp_2 = d;
   }
-  _tint_tmp_0 = (_tint_tmp_1);
+  tint_tmp_1 = (tint_tmp_2);
 }
 )");
 }
@@ -290,10 +290,10 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(result(), "(_tint_tmp)");
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = left;
-if (!_tint_tmp) {
-  _tint_tmp = right;
+  EXPECT_EQ(result(), "(tint_tmp)");
+  EXPECT_EQ(pre_result(), R"(bool tint_tmp = left;
+if (!tint_tmp) {
+  tint_tmp = right;
 }
 )");
 }
@@ -336,18 +336,18 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
-if (_tint_tmp) {
-  _tint_tmp = b;
+  EXPECT_EQ(result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
 }
-if ((_tint_tmp)) {
+if ((tint_tmp)) {
   return 1;
 } else {
-  bool _tint_tmp_0 = b;
-  if (!_tint_tmp_0) {
-    _tint_tmp_0 = c;
+  bool tint_tmp_1 = b;
+  if (!tint_tmp_1) {
+    tint_tmp_1 = c;
   }
-  if ((_tint_tmp_0)) {
+  if ((tint_tmp_1)) {
     return 2;
   } else {
     return 3;
@@ -369,15 +369,15 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
-if (_tint_tmp) {
-  _tint_tmp = b;
+  EXPECT_EQ(result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
 }
-bool _tint_tmp_0 = (_tint_tmp);
-if (!_tint_tmp_0) {
-  _tint_tmp_0 = c;
+bool tint_tmp_1 = (tint_tmp);
+if (!tint_tmp_1) {
+  tint_tmp_1 = c;
 }
-return (_tint_tmp_0);
+return (tint_tmp_1);
 )");
 }
 
@@ -397,15 +397,15 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = b;
-if (!_tint_tmp) {
-  _tint_tmp = c;
+  EXPECT_EQ(result(), R"(bool tint_tmp = b;
+if (!tint_tmp) {
+  tint_tmp = c;
 }
-bool _tint_tmp_0 = (_tint_tmp);
-if (_tint_tmp_0) {
-  _tint_tmp_0 = d;
+bool tint_tmp_1 = (tint_tmp);
+if (tint_tmp_1) {
+  tint_tmp_1 = d;
 }
-a = (_tint_tmp_0);
+a = (tint_tmp_1);
 )");
 }
 
@@ -432,15 +432,15 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitStatement(out, decl)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = b;
-if (_tint_tmp) {
-  _tint_tmp = c;
+  EXPECT_EQ(result(), R"(bool tint_tmp = b;
+if (tint_tmp) {
+  tint_tmp = c;
 }
-bool _tint_tmp_0 = (_tint_tmp);
-if (!_tint_tmp_0) {
-  _tint_tmp_0 = d;
+bool tint_tmp_1 = (tint_tmp);
+if (!tint_tmp_1) {
+  tint_tmp_1 = d;
 }
-bool a = (_tint_tmp_0);
+bool a = (tint_tmp_1);
 )");
 }
 
@@ -460,16 +460,16 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, expr)) << gen.error();
-  EXPECT_EQ(pre_result(), R"(bool _tint_tmp = a;
-if (_tint_tmp) {
-  bool _tint_tmp_0 = b;
-  if (!_tint_tmp_0) {
-    _tint_tmp_0 = c;
+  EXPECT_EQ(pre_result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  bool tint_tmp_1 = b;
+  if (!tint_tmp_1) {
+    tint_tmp_1 = c;
   }
-  _tint_tmp = (_tint_tmp_0);
+  tint_tmp = (tint_tmp_1);
 }
 )");
-  EXPECT_EQ(result(), R"(asint((_tint_tmp)))");
+  EXPECT_EQ(result(), R"(asint((tint_tmp)))");
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) {
@@ -500,27 +500,27 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitStatement(out, expr)) << gen.error();
-  EXPECT_EQ(result(), R"(bool _tint_tmp = a;
-if (_tint_tmp) {
-  _tint_tmp = b;
+  EXPECT_EQ(result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
 }
-bool _tint_tmp_0 = c;
-if (!_tint_tmp_0) {
-  _tint_tmp_0 = d;
+bool tint_tmp_1 = c;
+if (!tint_tmp_1) {
+  tint_tmp_1 = d;
 }
-bool _tint_tmp_1 = a;
-if (!_tint_tmp_1) {
-  _tint_tmp_1 = c;
+bool tint_tmp_2 = a;
+if (!tint_tmp_2) {
+  tint_tmp_2 = c;
 }
-bool _tint_tmp_2 = (_tint_tmp_1);
-if (_tint_tmp_2) {
-  bool _tint_tmp_3 = b;
-  if (!_tint_tmp_3) {
-    _tint_tmp_3 = d;
+bool tint_tmp_3 = (tint_tmp_2);
+if (tint_tmp_3) {
+  bool tint_tmp_4 = b;
+  if (!tint_tmp_4) {
+    tint_tmp_4 = d;
   }
-  _tint_tmp_2 = (_tint_tmp_3);
+  tint_tmp_3 = (tint_tmp_4);
 }
-foo((_tint_tmp), (_tint_tmp_0), (_tint_tmp_2));
+foo((tint_tmp), (tint_tmp_1), (tint_tmp_3));
 )");
 }
 
diff --git a/src/writer/hlsl/generator_impl_intrinsic_test.cc b/src/writer/hlsl/generator_impl_intrinsic_test.cc
index 372e145..baac6d1 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_test.cc
@@ -278,10 +278,10 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("int4 _tint_tmp = int4(round(clamp(p1, "
+  EXPECT_THAT(pre_result(), HasSubstr("int4 tint_tmp = int4(round(clamp(p1, "
                                       "-1.0, 1.0) * 127.0)) & 0xff;"));
-  EXPECT_THAT(result(), HasSubstr("asuint(_tint_tmp.x | _tint_tmp.y << 8 | "
-                                  "_tint_tmp.z << 16 | _tint_tmp.w << 24)"));
+  EXPECT_THAT(result(), HasSubstr("asuint(tint_tmp.x | tint_tmp.y << 8 | "
+                                  "tint_tmp.z << 16 | tint_tmp.w << 24)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Pack4x8Unorm) {
@@ -292,10 +292,10 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint4 _tint_tmp = uint4(round(clamp(p1, "
+  EXPECT_THAT(pre_result(), HasSubstr("uint4 tint_tmp = uint4(round(clamp(p1, "
                                       "0.0, 1.0) * 255.0));"));
-  EXPECT_THAT(result(), HasSubstr("(_tint_tmp.x | _tint_tmp.y << 8 | "
-                                  "_tint_tmp.z << 16 | _tint_tmp.w << 24)"));
+  EXPECT_THAT(result(), HasSubstr("(tint_tmp.x | tint_tmp.y << 8 | "
+                                  "tint_tmp.z << 16 | tint_tmp.w << 24)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Snorm) {
@@ -306,9 +306,9 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("int2 _tint_tmp = int2(round(clamp(p1, "
+  EXPECT_THAT(pre_result(), HasSubstr("int2 tint_tmp = int2(round(clamp(p1, "
                                       "-1.0, 1.0) * 32767.0)) & 0xffff;"));
-  EXPECT_THAT(result(), HasSubstr("asuint(_tint_tmp.x | _tint_tmp.y << 16)"));
+  EXPECT_THAT(result(), HasSubstr("asuint(tint_tmp.x | tint_tmp.y << 16)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Unorm) {
@@ -319,9 +319,9 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint2 _tint_tmp = uint2(round(clamp(p1, "
+  EXPECT_THAT(pre_result(), HasSubstr("uint2 tint_tmp = uint2(round(clamp(p1, "
                                       "0.0, 1.0) * 65535.0));"));
-  EXPECT_THAT(result(), HasSubstr("(_tint_tmp.x | _tint_tmp.y << 16)"));
+  EXPECT_THAT(result(), HasSubstr("(tint_tmp.x | tint_tmp.y << 16)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Float) {
@@ -332,8 +332,8 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint2 _tint_tmp = f32tof16(p1);"));
-  EXPECT_THAT(result(), HasSubstr("(_tint_tmp.x | _tint_tmp.y << 16)"));
+  EXPECT_THAT(pre_result(), HasSubstr("uint2 tint_tmp = f32tof16(p1);"));
+  EXPECT_THAT(result(), HasSubstr("(tint_tmp.x | tint_tmp.y << 16)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Unpack4x8Snorm) {
@@ -344,12 +344,12 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("int _tint_tmp_0 = int(p1);"));
+  EXPECT_THAT(pre_result(), HasSubstr("int tint_tmp_1 = int(p1);"));
   EXPECT_THAT(pre_result(),
-              HasSubstr("int4 _tint_tmp = int4(_tint_tmp_0 << 24, _tint_tmp_0 "
-                        "<< 16, _tint_tmp_0 << 8, _tint_tmp_0) >> 24;"));
+              HasSubstr("int4 tint_tmp = int4(tint_tmp_1 << 24, tint_tmp_1 "
+                        "<< 16, tint_tmp_1 << 8, tint_tmp_1) >> 24;"));
   EXPECT_THAT(result(),
-              HasSubstr("clamp(float4(_tint_tmp) / 127.0, -1.0, 1.0)"));
+              HasSubstr("clamp(float4(tint_tmp) / 127.0, -1.0, 1.0)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Unpack4x8Unorm) {
@@ -360,12 +360,12 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint _tint_tmp_0 = p1;"));
+  EXPECT_THAT(pre_result(), HasSubstr("uint tint_tmp_1 = p1;"));
   EXPECT_THAT(
       pre_result(),
-      HasSubstr("uint4 _tint_tmp = uint4(_tint_tmp_0 & 0xff, (_tint_tmp_0 >> "
-                "8) & 0xff, (_tint_tmp_0 >> 16) & 0xff, _tint_tmp_0 >> 24);"));
-  EXPECT_THAT(result(), HasSubstr("float4(_tint_tmp) / 255.0"));
+      HasSubstr("uint4 tint_tmp = uint4(tint_tmp_1 & 0xff, (tint_tmp_1 >> "
+                "8) & 0xff, (tint_tmp_1 >> 16) & 0xff, tint_tmp_1 >> 24);"));
+  EXPECT_THAT(result(), HasSubstr("float4(tint_tmp) / 255.0"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Unpack2x16Snorm) {
@@ -376,13 +376,12 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("int _tint_tmp_0 = int(p1);"));
+  EXPECT_THAT(pre_result(), HasSubstr("int tint_tmp_1 = int(p1);"));
   EXPECT_THAT(
       pre_result(),
-      HasSubstr(
-          "int2 _tint_tmp = int2(_tint_tmp_0 << 16, _tint_tmp_0) >> 16;"));
+      HasSubstr("int2 tint_tmp = int2(tint_tmp_1 << 16, tint_tmp_1) >> 16;"));
   EXPECT_THAT(result(),
-              HasSubstr("clamp(float2(_tint_tmp) / 32767.0, -1.0, 1.0)"));
+              HasSubstr("clamp(float2(tint_tmp) / 32767.0, -1.0, 1.0)"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Unpack2x16Unorm) {
@@ -393,12 +392,12 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint _tint_tmp_0 = p1;"));
+  EXPECT_THAT(pre_result(), HasSubstr("uint tint_tmp_1 = p1;"));
   EXPECT_THAT(
       pre_result(),
       HasSubstr(
-          "uint2 _tint_tmp = uint2(_tint_tmp_0 & 0xffff, _tint_tmp_0 >> 16);"));
-  EXPECT_THAT(result(), HasSubstr("float2(_tint_tmp) / 65535.0"));
+          "uint2 tint_tmp = uint2(tint_tmp_1 & 0xffff, tint_tmp_1 >> 16);"));
+  EXPECT_THAT(result(), HasSubstr("float2(tint_tmp) / 65535.0"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Unpack2x16Float) {
@@ -409,10 +408,9 @@
 
   gen.increment_indent();
   ASSERT_TRUE(gen.EmitExpression(pre, out, call)) << gen.error();
-  EXPECT_THAT(pre_result(), HasSubstr("uint _tint_tmp = p1;"));
-  EXPECT_THAT(
-      result(),
-      HasSubstr("f16tof32(uint2(_tint_tmp & 0xffff, _tint_tmp >> 16))"));
+  EXPECT_THAT(pre_result(), HasSubstr("uint tint_tmp = p1;"));
+  EXPECT_THAT(result(),
+              HasSubstr("f16tof32(uint2(tint_tmp & 0xffff, tint_tmp >> 16))"));
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, StorageBarrier) {
diff --git a/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc b/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
index fe46286..0633929 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_texture_test.cc
@@ -41,27 +41,27 @@
     case ValidTextureOverload::kDimensionsStorageRO1d:
     case ValidTextureOverload::kDimensionsStorageWO1d:
       return {
-          R"(int _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp);
+          R"(int tint_tmp;
+  tint_texture.GetDimensions(tint_tmp);
 )",
-          "_tint_tmp",
+          "tint_tmp",
       };
     case ValidTextureOverload::kDimensions2d:
     case ValidTextureOverload::kDimensionsDepth2d:
     case ValidTextureOverload::kDimensionsStorageRO2d:
     case ValidTextureOverload::kDimensionsStorageWO2d:
       return {
-          R"(int2 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y);
+          R"(int2 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y);
 )",
-          "_tint_tmp",
+          "tint_tmp",
       };
     case ValidTextureOverload::kDimensionsMultisampled2d:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.xy",
+          "tint_tmp.xy",
       };
 
     case ValidTextureOverload::kDimensions2dArray:
@@ -69,81 +69,81 @@
     case ValidTextureOverload::kDimensionsStorageRO2dArray:
     case ValidTextureOverload::kDimensionsStorageWO2dArray:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.xy",
+          "tint_tmp.xy",
       };
     case ValidTextureOverload::kDimensionsMultisampled2dArray:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.xy",
+          "tint_tmp.xy",
       };
     case ValidTextureOverload::kDimensions3d:
     case ValidTextureOverload::kDimensionsStorageRO3d:
     case ValidTextureOverload::kDimensionsStorageWO3d:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp",
+          "tint_tmp",
       };
     case ValidTextureOverload::kDimensionsCube:
     case ValidTextureOverload::kDimensionsDepthCube:
       return {
-          R"(int2 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y);
+          R"(int2 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y);
 )",
-          "_tint_tmp.xyy",
+          "tint_tmp.xyy",
       };
     case ValidTextureOverload::kDimensionsCubeArray:
     case ValidTextureOverload::kDimensionsDepthCubeArray:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.xyy",
+          "tint_tmp.xyy",
       };
     case ValidTextureOverload::kDimensions2dLevel:
     case ValidTextureOverload::kDimensionsDepth2dLevel:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(1, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.xy",
+          "tint_tmp.xy",
       };
     case ValidTextureOverload::kDimensions2dArrayLevel:
     case ValidTextureOverload::kDimensionsDepth2dArrayLevel:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(1, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.xy",
+          "tint_tmp.xy",
       };
     case ValidTextureOverload::kDimensions3dLevel:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(1, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.xyz",
+          "tint_tmp.xyz",
       };
     case ValidTextureOverload::kDimensionsCubeLevel:
     case ValidTextureOverload::kDimensionsDepthCubeLevel:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(1, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.xyy",
+          "tint_tmp.xyy",
       };
     case ValidTextureOverload::kDimensionsCubeArrayLevel:
     case ValidTextureOverload::kDimensionsDepthCubeArrayLevel:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(1, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.xyy",
+          "tint_tmp.xyy",
       };
     case ValidTextureOverload::kNumLayers2dArray:
     case ValidTextureOverload::kNumLayersDepth2dArray:
@@ -151,17 +151,17 @@
     case ValidTextureOverload::kNumLayersDepthCubeArray:
     case ValidTextureOverload::kNumLayersStorageWO2dArray:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.z",
+          "tint_tmp.z",
       };
     case ValidTextureOverload::kNumLayersMultisampled2dArray:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.z",
+          "tint_tmp.z",
       };
 
     case ValidTextureOverload::kNumLevels2d:
@@ -169,10 +169,10 @@
     case ValidTextureOverload::kNumLevelsDepth2d:
     case ValidTextureOverload::kNumLevelsDepthCube:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(0, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.z",
+          "tint_tmp.z",
       };
     case ValidTextureOverload::kNumLevels2dArray:
     case ValidTextureOverload::kNumLevels3d:
@@ -180,24 +180,24 @@
     case ValidTextureOverload::kNumLevelsDepth2dArray:
     case ValidTextureOverload::kNumLevelsDepthCubeArray:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(0, _tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.w",
+          "tint_tmp.w",
       };
     case ValidTextureOverload::kNumSamplesMultisampled2d:
       return {
-          R"(int3 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z);
+          R"(int3 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
 )",
-          "_tint_tmp.z",
+          "tint_tmp.z",
       };
     case ValidTextureOverload::kNumSamplesMultisampled2dArray:
       return {
-          R"(int4 _tint_tmp;
-  tint_texture.GetDimensions(_tint_tmp.x, _tint_tmp.y, _tint_tmp.z, _tint_tmp.w);
+          R"(int4 tint_tmp;
+  tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
 )",
-          "_tint_tmp.w",
+          "tint_tmp.w",
       };
     case ValidTextureOverload::kSample1dF32:
       return R"(tint_texture.Sample(tint_sampler, 1.0f))";
diff --git a/src/writer/hlsl/generator_impl_test.cc b/src/writer/hlsl/generator_impl_test.cc
index a47cd9e..773c1de 100644
--- a/src/writer/hlsl/generator_impl_test.cc
+++ b/src/writer/hlsl/generator_impl_test.cc
@@ -47,9 +47,9 @@
   GeneratorImpl& gen = Build();
 
   ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out");
-  ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_0");
   ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_3");
   ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_4");
+  ASSERT_EQ(gen.generate_name("func_main_out"), "func_main_out_5");
 }
 
 struct HlslBuiltinData {