Add a symbol to the Identifier AST node This CL adds a Symbol to the identifier to represent the name. The name still exists but will be removed in a future CL when the namers are in place. Change-Id: Ic3cc8ad0d99e3bea6eb1ff1ce212e7de67991aec Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/35460 Commit-Queue: dan sinclair <dsinclair@chromium.org> Auto-Submit: dan sinclair <dsinclair@chromium.org> Reviewed-by: Ben Clayton <bclayton@google.com>

diff --git a/src/ast/array_accessor_expression_test.cc b/src/ast/array_accessor_expression_test.cc
index 9526284..9bb30e0 100644
--- a/src/ast/array_accessor_expression_test.cc
+++ b/src/ast/array_accessor_expression_test.cc

@@ -24,8 +24,8 @@
 using ArrayAccessorExpressionTest = TestHelper;
 
 TEST_F(ArrayAccessorExpressionTest, Create) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(ary, idx);
   ASSERT_EQ(exp.array(), ary);
@@ -33,8 +33,8 @@
 }
 
 TEST_F(ArrayAccessorExpressionTest, CreateWithSource) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(Source{Source::Location{20, 2}}, ary, idx);
   auto src = exp.source();
@@ -43,58 +43,58 @@
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(ary, idx);
   EXPECT_TRUE(exp.Is<ArrayAccessorExpression>());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(ary, idx);
   EXPECT_TRUE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid_MissingArray) {
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(nullptr, idx);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid_MissingIndex) {
-  auto* ary = create<IdentifierExpression>("ary");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
 
   ArrayAccessorExpression exp(ary, nullptr);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid_InvalidArray) {
-  auto* ary = create<IdentifierExpression>("");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
   ArrayAccessorExpression exp(ary, idx);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid_InvalidIndex) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   ArrayAccessorExpression exp(ary, idx);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, ToStr) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
+  auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ArrayAccessorExpression exp(ary, idx);
   std::ostringstream out;
   exp.to_str(out, 2);
 
-  EXPECT_EQ(out.str(), R"(  ArrayAccessor[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  ArrayAccessor[not set]{
     Identifier[not set]{ary}
     Identifier[not set]{idx}
   }

diff --git a/src/ast/assignment_statement_test.cc b/src/ast/assignment_statement_test.cc
index 8fa68a4..4f69c58 100644
--- a/src/ast/assignment_statement_test.cc
+++ b/src/ast/assignment_statement_test.cc

@@ -24,8 +24,8 @@
 using AssignmentStatementTest = TestHelper;
 
 TEST_F(AssignmentStatementTest, Creation) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(lhs, rhs);
   EXPECT_EQ(stmt.lhs(), lhs);
@@ -33,8 +33,8 @@
 }
 
 TEST_F(AssignmentStatementTest, CreationWithSource) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(Source{Source::Location{20, 2}}, lhs, rhs);
   auto src = stmt.source();
@@ -43,58 +43,58 @@
 }
 
 TEST_F(AssignmentStatementTest, IsAssign) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(lhs, rhs);
   EXPECT_TRUE(stmt.Is<AssignmentStatement>());
 }
 
 TEST_F(AssignmentStatementTest, IsValid) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(lhs, rhs);
   EXPECT_TRUE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, IsValid_MissingLHS) {
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(nullptr, rhs);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, IsValid_MissingRHS) {
-  auto* lhs = create<IdentifierExpression>("lhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
 
   AssignmentStatement stmt(lhs, nullptr);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, IsValid_InvalidLHS) {
-  auto* lhs = create<IdentifierExpression>("");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
   AssignmentStatement stmt(lhs, rhs);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, IsValid_InvalidRHS) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   AssignmentStatement stmt(lhs, rhs);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, ToStr) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   AssignmentStatement stmt(lhs, rhs);
   std::ostringstream out;
   stmt.to_str(out, 2);
 
-  EXPECT_EQ(out.str(), R"(  Assignment{
+  EXPECT_EQ(demangle(out.str()), R"(  Assignment{
     Identifier[not set]{lhs}
     Identifier[not set]{rhs}
   }

diff --git a/src/ast/binary_expression_test.cc b/src/ast/binary_expression_test.cc
index 6494a78..ecba1ac 100644
--- a/src/ast/binary_expression_test.cc
+++ b/src/ast/binary_expression_test.cc

@@ -26,8 +26,8 @@
 using BinaryExpressionTest = TestHelper;
 
 TEST_F(BinaryExpressionTest, Creation) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   EXPECT_EQ(r.lhs(), lhs);
@@ -36,8 +36,8 @@
 }
 
 TEST_F(BinaryExpressionTest, Creation_WithSource) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(Source{Source::Location{20, 2}}, BinaryOp::kEqual, lhs,
                      rhs);
@@ -47,67 +47,67 @@
 }
 
 TEST_F(BinaryExpressionTest, IsBinary) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   EXPECT_TRUE(r.Is<BinaryExpression>());
 }
 
 TEST_F(BinaryExpressionTest, IsValid) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   EXPECT_TRUE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, IsValid_Null_LHS) {
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, nullptr, rhs);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, IsValid_Invalid_LHS) {
-  auto* lhs = create<IdentifierExpression>("");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, IsValid_Null_RHS) {
-  auto* lhs = create<IdentifierExpression>("lhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, nullptr);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, IsValid_Invalid_RHS) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, IsValid_Binary_None) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kNone, lhs, rhs);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(BinaryExpressionTest, ToStr) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
+  auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
   std::ostringstream out;
   r.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Binary[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  Binary[not set]{
     Identifier[not set]{lhs}
     equal
     Identifier[not set]{rhs}

diff --git a/src/ast/bitcast_expression_test.cc b/src/ast/bitcast_expression_test.cc
index 1c8afc1..ebf8ec0 100644
--- a/src/ast/bitcast_expression_test.cc
+++ b/src/ast/bitcast_expression_test.cc

@@ -26,7 +26,7 @@
 
 TEST_F(BitcastExpressionTest, Create) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(&f32, expr);
   ASSERT_EQ(exp.type(), &f32);
@@ -35,7 +35,7 @@
 
 TEST_F(BitcastExpressionTest, CreateWithSource) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(Source{Source::Location{20, 2}}, &f32, expr);
   auto src = exp.source();
@@ -45,7 +45,7 @@
 
 TEST_F(BitcastExpressionTest, IsBitcast) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(&f32, expr);
   EXPECT_TRUE(exp.Is<BitcastExpression>());
@@ -53,14 +53,14 @@
 
 TEST_F(BitcastExpressionTest, IsValid) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(&f32, expr);
   EXPECT_TRUE(exp.IsValid());
 }
 
 TEST_F(BitcastExpressionTest, IsValid_MissingType) {
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(nullptr, expr);
   EXPECT_FALSE(exp.IsValid());
@@ -75,20 +75,20 @@
 
 TEST_F(BitcastExpressionTest, IsValid_InvalidExpr) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   BitcastExpression e(&f32, expr);
   EXPECT_FALSE(e.IsValid());
 }
 
 TEST_F(BitcastExpressionTest, ToStr) {
   type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   BitcastExpression exp(&f32, expr);
   std::ostringstream out;
   exp.to_str(out, 2);
 
-  EXPECT_EQ(out.str(), R"(  Bitcast[not set]<__f32>{
+  EXPECT_EQ(demangle(out.str()), R"(  Bitcast[not set]<__f32>{
     Identifier[not set]{expr}
   }
 )");

diff --git a/src/ast/builder.h b/src/ast/builder.h
index 4a01d50..189ebdb 100644
--- a/src/ast/builder.h
+++ b/src/ast/builder.h

@@ -206,13 +206,13 @@
   /// @param name the identifier name
   /// @return an IdentifierExpression with the given name
   IdentifierExpression* Expr(const std::string& name) {
-    return create<IdentifierExpression>(name);
+    return create<IdentifierExpression>(mod->RegisterSymbol(name), name);
   }
 
   /// @param name the identifier name
   /// @return an IdentifierExpression with the given name
   IdentifierExpression* Expr(const char* name) {
-    return create<IdentifierExpression>(name);
+    return create<IdentifierExpression>(mod->RegisterSymbol(name), name);
   }
 
   /// @param value the boolean value

diff --git a/src/ast/call_expression_test.cc b/src/ast/call_expression_test.cc
index be84072..4b59395 100644
--- a/src/ast/call_expression_test.cc
+++ b/src/ast/call_expression_test.cc

@@ -24,10 +24,12 @@
 using CallExpressionTest = TestHelper;
 
 TEST_F(CallExpressionTest, Creation) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   ExpressionList params;
-  params.push_back(create<IdentifierExpression>("param1"));
-  params.push_back(create<IdentifierExpression>("param2"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
 
   CallExpression stmt(func, params);
   EXPECT_EQ(stmt.func(), func);
@@ -39,7 +41,7 @@
 }
 
 TEST_F(CallExpressionTest, Creation_WithSource) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   CallExpression stmt(Source{Source::Location{20, 2}}, func, {});
   auto src = stmt.source();
   EXPECT_EQ(src.range.begin.line, 20u);
@@ -47,13 +49,13 @@
 }
 
 TEST_F(CallExpressionTest, IsCall) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   CallExpression stmt(func, {});
   EXPECT_TRUE(stmt.Is<CallExpression>());
 }
 
 TEST_F(CallExpressionTest, IsValid) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   CallExpression stmt(func, {});
   EXPECT_TRUE(stmt.IsValid());
 }
@@ -64,40 +66,43 @@
 }
 
 TEST_F(CallExpressionTest, IsValid_NullParam) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   ExpressionList params;
-  params.push_back(create<IdentifierExpression>("param1"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
   params.push_back(nullptr);
-  params.push_back(create<IdentifierExpression>("param2"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
 
   CallExpression stmt(func, params);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(CallExpressionTest, IsValid_InvalidFunction) {
-  auto* func = create<IdentifierExpression>("");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   ExpressionList params;
-  params.push_back(create<IdentifierExpression>("param1"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
 
   CallExpression stmt(func, params);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(CallExpressionTest, IsValid_InvalidParam) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   ExpressionList params;
-  params.push_back(create<IdentifierExpression>(""));
+  params.push_back(create<IdentifierExpression>(mod.RegisterSymbol(""), ""));
 
   CallExpression stmt(func, params);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(CallExpressionTest, ToStr_NoParams) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   CallExpression stmt(func, {});
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Call[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  Call[not set]{
     Identifier[not set]{func}
     (
     )
@@ -106,15 +111,17 @@
 }
 
 TEST_F(CallExpressionTest, ToStr_WithParams) {
-  auto* func = create<IdentifierExpression>("func");
+  auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
   ExpressionList params;
-  params.push_back(create<IdentifierExpression>("param1"));
-  params.push_back(create<IdentifierExpression>("param2"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
 
   CallExpression stmt(func, params);
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Call[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  Call[not set]{
     Identifier[not set]{func}
     (
       Identifier[not set]{param1}

diff --git a/src/ast/call_statement_test.cc b/src/ast/call_statement_test.cc
index 8a0e7b5..44f3604 100644
--- a/src/ast/call_statement_test.cc
+++ b/src/ast/call_statement_test.cc

@@ -25,8 +25,9 @@
 using CallStatementTest = TestHelper;
 
 TEST_F(CallStatementTest, Creation) {
-  auto* expr = create<CallExpression>(create<IdentifierExpression>("func"),
-                                      ExpressionList{});
+  auto* expr = create<CallExpression>(
+      create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
+      ExpressionList{});
 
   CallStatement c(expr);
   EXPECT_EQ(c.expr(), expr);
@@ -38,8 +39,9 @@
 }
 
 TEST_F(CallStatementTest, IsValid) {
-  CallStatement c(create<CallExpression>(create<IdentifierExpression>("func"),
-                                         ExpressionList{}));
+  CallStatement c(create<CallExpression>(
+      create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
+      ExpressionList{}));
   EXPECT_TRUE(c.IsValid());
 }
 
@@ -55,12 +57,13 @@
 }
 
 TEST_F(CallStatementTest, ToStr) {
-  CallStatement c(create<CallExpression>(create<IdentifierExpression>("func"),
-                                         ExpressionList{}));
+  CallStatement c(create<CallExpression>(
+      create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
+      ExpressionList{}));
 
   std::ostringstream out;
   c.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Call[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  Call[not set]{
     Identifier[not set]{func}
     (
     )

diff --git a/src/ast/identifier_expression.cc b/src/ast/identifier_expression.cc
index d4770db..04ae344 100644
--- a/src/ast/identifier_expression.cc
+++ b/src/ast/identifier_expression.cc

@@ -22,28 +22,30 @@
 namespace tint {
 namespace ast {
 
-IdentifierExpression::IdentifierExpression(const std::string& name)
-    : Base(), name_(name) {}
+IdentifierExpression::IdentifierExpression(Symbol sym, const std::string& name)
+    : Base(), sym_(sym), name_(name) {}
 
 IdentifierExpression::IdentifierExpression(const Source& source,
+                                           Symbol sym,
                                            const std::string& name)
-    : Base(source), name_(name) {}
+    : Base(source), sym_(sym), name_(name) {}
 
 IdentifierExpression::IdentifierExpression(IdentifierExpression&&) = default;
 
 IdentifierExpression::~IdentifierExpression() = default;
 
 IdentifierExpression* IdentifierExpression::Clone(CloneContext* ctx) const {
-  return ctx->mod->create<IdentifierExpression>(ctx->Clone(source()), name_);
+  return ctx->mod->create<IdentifierExpression>(ctx->Clone(source()), sym_,
+                                                name_);
 }
 
 bool IdentifierExpression::IsValid() const {
-  return !name_.empty();
+  return sym_.IsValid();
 }
 
 void IdentifierExpression::to_str(std::ostream& out, size_t indent) const {
   make_indent(out, indent);
-  out << "Identifier[" << result_type_str() << "]{" << name_ << "}"
+  out << "Identifier[" << result_type_str() << "]{" << sym_.to_str() << "}"
       << std::endl;
 }
 

diff --git a/src/ast/identifier_expression.h b/src/ast/identifier_expression.h
index 703c041..9fa2660 100644
--- a/src/ast/identifier_expression.h
+++ b/src/ast/identifier_expression.h

@@ -21,6 +21,7 @@
 
 #include "src/ast/expression.h"
 #include "src/ast/intrinsic.h"
+#include "src/symbol.h"
 
 namespace tint {
 namespace ast {
@@ -29,16 +30,22 @@
 class IdentifierExpression : public Castable<IdentifierExpression, Expression> {
  public:
   /// Constructor
+  /// @param sym the symbol for the identifier
   /// @param name the name
-  explicit IdentifierExpression(const std::string& name);
+  explicit IdentifierExpression(Symbol sym, const std::string& name);
   /// Constructor
   /// @param source the source
+  /// @param sym the symbol for the identifier
   /// @param name the name
-  IdentifierExpression(const Source& source, const std::string& name);
+  IdentifierExpression(const Source& source,
+                       Symbol sym,
+                       const std::string& name);
   /// Move constructor
   IdentifierExpression(IdentifierExpression&&);
   ~IdentifierExpression() override;
 
+  /// @returns the symbol for the identifier
+  Symbol symbol() const { return sym_; }
   /// @returns the name part of the identifier
   std::string name() const { return name_; }
 
@@ -82,6 +89,7 @@
 
   Intrinsic intrinsic_ = Intrinsic::kNone;
   std::unique_ptr<intrinsic::Signature> intrinsic_sig_;
+  Symbol sym_;
   std::string name_;
 };
 

diff --git a/src/ast/identifier_expression_test.cc b/src/ast/identifier_expression_test.cc
index 7ef416e..a81f9cd 100644
--- a/src/ast/identifier_expression_test.cc
+++ b/src/ast/identifier_expression_test.cc

@@ -23,12 +23,15 @@
 using IdentifierExpressionTest = TestHelper;
 
 TEST_F(IdentifierExpressionTest, Creation) {
-  IdentifierExpression i("ident");
+  IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
+  EXPECT_EQ(i.symbol(), Symbol(1));
   EXPECT_EQ(i.name(), "ident");
 }
 
 TEST_F(IdentifierExpressionTest, Creation_WithSource) {
-  IdentifierExpression i(Source{Source::Location{20, 2}}, "ident");
+  IdentifierExpression i(Source{Source::Location{20, 2}},
+                         mod.RegisterSymbol("ident"), "ident");
+  EXPECT_EQ(i.symbol(), Symbol(1));
   EXPECT_EQ(i.name(), "ident");
 
   auto src = i.source();
@@ -37,25 +40,20 @@
 }
 
 TEST_F(IdentifierExpressionTest, IsIdentifier) {
-  IdentifierExpression i("ident");
+  IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
   EXPECT_TRUE(i.Is<IdentifierExpression>());
 }
 
 TEST_F(IdentifierExpressionTest, IsValid) {
-  IdentifierExpression i("ident");
+  IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
   EXPECT_TRUE(i.IsValid());
 }
 
-TEST_F(IdentifierExpressionTest, IsValid_BlankName) {
-  IdentifierExpression i("");
-  EXPECT_FALSE(i.IsValid());
-}
-
 TEST_F(IdentifierExpressionTest, ToStr) {
-  IdentifierExpression i("ident");
+  IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
   std::ostringstream out;
   i.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Identifier[not set]{ident}
+  EXPECT_EQ(demangle(out.str()), R"(  Identifier[not set]{ident}
 )");
 }
 

diff --git a/src/ast/if_statement_test.cc b/src/ast/if_statement_test.cc
index e3117cd..3314e9d 100644
--- a/src/ast/if_statement_test.cc
+++ b/src/ast/if_statement_test.cc

@@ -25,7 +25,7 @@
 using IfStatementTest = TestHelper;
 
 TEST_F(IfStatementTest, Creation) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -43,7 +43,7 @@
 }
 
 TEST_F(IfStatementTest, IsValid) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -52,14 +52,15 @@
 }
 
 TEST_F(IfStatementTest, IsValid_WithElseStatements) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
   IfStatement stmt(
       Source{}, cond, body,
       {
-          create<ElseStatement>(create<IdentifierExpression>("Ident"),
+          create<ElseStatement>(create<IdentifierExpression>(
+                                    mod.RegisterSymbol("Ident"), "Ident"),
                                 create<BlockStatement>()),
           create<ElseStatement>(create<BlockStatement>()),
       });
@@ -75,7 +76,7 @@
 }
 
 TEST_F(IfStatementTest, IsValid_InvalidCondition) {
-  auto* cond = create<IdentifierExpression>("");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -84,7 +85,7 @@
 }
 
 TEST_F(IfStatementTest, IsValid_NullBodyStatement) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
   body->append(nullptr);
@@ -94,7 +95,7 @@
 }
 
 TEST_F(IfStatementTest, IsValid_InvalidBodyStatement) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
   body->append(create<IfStatement>(Source{}, nullptr, create<BlockStatement>(),
@@ -105,14 +106,15 @@
 }
 
 TEST_F(IfStatementTest, IsValid_NullElseStatement) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
   IfStatement stmt(
       Source{}, cond, body,
       {
-          create<ElseStatement>(create<IdentifierExpression>("Ident"),
+          create<ElseStatement>(create<IdentifierExpression>(
+                                    mod.RegisterSymbol("Ident"), "Ident"),
                                 create<BlockStatement>()),
           create<ElseStatement>(create<BlockStatement>()),
           nullptr,
@@ -121,20 +123,21 @@
 }
 
 TEST_F(IfStatementTest, IsValid_InvalidElseStatement) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
   IfStatement stmt(Source{}, cond, body,
                    {
-                       create<ElseStatement>(create<IdentifierExpression>(""),
+                       create<ElseStatement>(create<IdentifierExpression>(
+                                                 mod.RegisterSymbol(""), ""),
                                              create<BlockStatement>()),
                    });
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(IfStatementTest, IsValid_MultipleElseWiththoutCondition) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -147,7 +150,7 @@
 }
 
 TEST_F(IfStatementTest, IsValid_ElseNotLast) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -155,14 +158,15 @@
       Source{}, cond, body,
       {
           create<ElseStatement>(create<BlockStatement>()),
-          create<ElseStatement>(create<IdentifierExpression>("ident"),
+          create<ElseStatement>(create<IdentifierExpression>(
+                                    mod.RegisterSymbol("ident"), "ident"),
                                 create<BlockStatement>()),
       });
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(IfStatementTest, ToStr) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -170,7 +174,7 @@
 
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  If{
+  EXPECT_EQ(demangle(out.str()), R"(  If{
     (
       Identifier[not set]{cond}
     )
@@ -182,7 +186,7 @@
 }
 
 TEST_F(IfStatementTest, ToStr_WithElseStatements) {
-  auto* cond = create<IdentifierExpression>("cond");
+  auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
@@ -193,16 +197,18 @@
   else_body->append(create<DiscardStatement>());
   else_body->append(create<DiscardStatement>());
 
-  IfStatement stmt(Source{}, cond, body,
-                   {
-                       create<ElseStatement>(
-                           create<IdentifierExpression>("ident"), else_if_body),
-                       create<ElseStatement>(else_body),
-                   });
+  IfStatement stmt(
+      Source{}, cond, body,
+      {
+          create<ElseStatement>(create<IdentifierExpression>(
+                                    mod.RegisterSymbol("ident"), "ident"),
+                                else_if_body),
+          create<ElseStatement>(else_body),
+      });
 
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  If{
+  EXPECT_EQ(demangle(out.str()), R"(  If{
     (
       Identifier[not set]{cond}
     )

diff --git a/src/ast/member_accessor_expression_test.cc b/src/ast/member_accessor_expression_test.cc
index d307b80..3985ce1 100644
--- a/src/ast/member_accessor_expression_test.cc
+++ b/src/ast/member_accessor_expression_test.cc

@@ -26,8 +26,10 @@
 using MemberAccessorExpressionTest = TestHelper;
 
 TEST_F(MemberAccessorExpressionTest, Creation) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(str, mem);
   EXPECT_EQ(stmt.structure(), str);
@@ -35,8 +37,10 @@
 }
 
 TEST_F(MemberAccessorExpressionTest, Creation_WithSource) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(Source{Source::Location{20, 2}}, str, mem);
   auto src = stmt.source();
@@ -45,59 +49,69 @@
 }
 
 TEST_F(MemberAccessorExpressionTest, IsMemberAccessor) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(str, mem);
   EXPECT_TRUE(stmt.Is<MemberAccessorExpression>());
 }
 
 TEST_F(MemberAccessorExpressionTest, IsValid) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(str, mem);
   EXPECT_TRUE(stmt.IsValid());
 }
 
 TEST_F(MemberAccessorExpressionTest, IsValid_NullStruct) {
-  auto* mem = create<IdentifierExpression>("member");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(nullptr, mem);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(MemberAccessorExpressionTest, IsValid_InvalidStruct) {
-  auto* str = create<IdentifierExpression>("");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(str, mem);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(MemberAccessorExpressionTest, IsValid_NullMember) {
-  auto* str = create<IdentifierExpression>("structure");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
 
   MemberAccessorExpression stmt(str, nullptr);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(MemberAccessorExpressionTest, IsValid_InvalidMember) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
 
   MemberAccessorExpression stmt(str, mem);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(MemberAccessorExpressionTest, ToStr) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
+  auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
+                                           "structure");
+  auto* mem =
+      create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
 
   MemberAccessorExpression stmt(str, mem);
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  MemberAccessor[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  MemberAccessor[not set]{
     Identifier[not set]{structure}
     Identifier[not set]{member}
   }

diff --git a/src/ast/module.cc b/src/ast/module.cc
index 2132e1f..32dfbef 100644
--- a/src/ast/module.cc
+++ b/src/ast/module.cc

@@ -38,6 +38,10 @@
 }
 
 void Module::Clone(CloneContext* ctx) {
+  // Symbol table must be cloned first so that the resulting module has the
+  // symbols before we start the tree mutations.
+  ctx->mod->symbol_table_ = symbol_table_;
+
   for (auto* ty : constructed_types_) {
     ctx->mod->constructed_types_.emplace_back(ctx->Clone(ty));
   }
@@ -47,8 +51,6 @@
   for (auto* func : functions_) {
     ctx->mod->functions_.emplace_back(ctx->Clone(func));
   }
-
-  ctx->mod->symbol_table_ = symbol_table_;
 }
 
 Function* Module::FindFunctionBySymbol(Symbol sym) const {

diff --git a/src/ast/return_statement_test.cc b/src/ast/return_statement_test.cc
index 8e9e525..c7d46b0 100644
--- a/src/ast/return_statement_test.cc
+++ b/src/ast/return_statement_test.cc

@@ -26,7 +26,7 @@
 using ReturnStatementTest = TestHelper;
 
 TEST_F(ReturnStatementTest, Creation) {
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
 
   ReturnStatement r(Source{}, expr);
   EXPECT_EQ(r.value(), expr);
@@ -50,7 +50,7 @@
 }
 
 TEST_F(ReturnStatementTest, HasValue_WithValue) {
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ReturnStatement r(Source{}, expr);
   EXPECT_TRUE(r.has_value());
 }
@@ -61,23 +61,23 @@
 }
 
 TEST_F(ReturnStatementTest, IsValid_WithValue) {
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ReturnStatement r(Source{}, expr);
   EXPECT_TRUE(r.IsValid());
 }
 
 TEST_F(ReturnStatementTest, IsValid_InvalidValue) {
-  auto* expr = create<IdentifierExpression>("");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   ReturnStatement r(Source{}, expr);
   EXPECT_FALSE(r.IsValid());
 }
 
 TEST_F(ReturnStatementTest, ToStr_WithValue) {
-  auto* expr = create<IdentifierExpression>("expr");
+  auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ReturnStatement r(Source{}, expr);
   std::ostringstream out;
   r.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Return{
+  EXPECT_EQ(demangle(out.str()), R"(  Return{
     {
       Identifier[not set]{expr}
     }

diff --git a/src/ast/switch_statement_test.cc b/src/ast/switch_statement_test.cc
index df82f3d..bd610fa 100644
--- a/src/ast/switch_statement_test.cc
+++ b/src/ast/switch_statement_test.cc

@@ -34,7 +34,8 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 1));
 
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   CaseStatementList body;
   auto* case_stmt = create<CaseStatement>(lit, create<BlockStatement>());
   body.push_back(case_stmt);
@@ -46,7 +47,8 @@
 }
 
 TEST_F(SwitchStatementTest, Creation_WithSource) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
 
   SwitchStatement stmt(Source{Source::Location{20, 2}}, ident,
                        CaseStatementList());
@@ -61,7 +63,8 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 2));
 
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
 
@@ -75,7 +78,8 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 2));
 
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
 
@@ -102,7 +106,7 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 2));
 
-  auto* ident = create<IdentifierExpression>("");
+  auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
 
@@ -116,7 +120,8 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 2));
 
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
   body.push_back(nullptr);
@@ -126,7 +131,8 @@
 }
 
 TEST_F(SwitchStatementTest, IsValid_Invalid_BodyStatement) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
 
   auto* case_body = create<BlockStatement>();
   case_body->append(nullptr);
@@ -139,12 +145,13 @@
 }
 
 TEST_F(SwitchStatementTest, ToStr_Empty) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
 
   SwitchStatement stmt(ident, {});
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Switch{
+  EXPECT_EQ(demangle(out.str()), R"(  Switch{
     Identifier[not set]{ident}
     {
     }
@@ -158,14 +165,15 @@
   CaseSelectorList lit;
   lit.push_back(create<SintLiteral>(&i32, 2));
 
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
 
   SwitchStatement stmt(ident, body);
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Switch{
+  EXPECT_EQ(demangle(out.str()), R"(  Switch{
     Identifier[not set]{ident}
     {
       Case 2{

diff --git a/src/ast/type_constructor_expression_test.cc b/src/ast/type_constructor_expression_test.cc
index d7efed7..3fbf937 100644
--- a/src/ast/type_constructor_expression_test.cc
+++ b/src/ast/type_constructor_expression_test.cc

@@ -32,7 +32,8 @@
 TEST_F(TypeConstructorExpressionTest, Creation) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
 
   TypeConstructorExpression t(&f32, expr);
   EXPECT_EQ(t.type(), &f32);
@@ -43,7 +44,8 @@
 TEST_F(TypeConstructorExpressionTest, Creation_WithSource) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
 
   TypeConstructorExpression t(Source{Source::Location{20, 2}}, &f32, expr);
   auto src = t.source();
@@ -54,7 +56,8 @@
 TEST_F(TypeConstructorExpressionTest, IsTypeConstructor) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
 
   TypeConstructorExpression t(&f32, expr);
   EXPECT_TRUE(t.Is<TypeConstructorExpression>());
@@ -63,7 +66,8 @@
 TEST_F(TypeConstructorExpressionTest, IsValid) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
 
   TypeConstructorExpression t(&f32, expr);
   EXPECT_TRUE(t.IsValid());
@@ -79,7 +83,8 @@
 
 TEST_F(TypeConstructorExpressionTest, IsValid_NullType) {
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
 
   TypeConstructorExpression t(nullptr, expr);
   EXPECT_FALSE(t.IsValid());
@@ -88,7 +93,8 @@
 TEST_F(TypeConstructorExpressionTest, IsValid_NullValue) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
   expr.push_back(nullptr);
 
   TypeConstructorExpression t(&f32, expr);
@@ -98,7 +104,7 @@
 TEST_F(TypeConstructorExpressionTest, IsValid_InvalidValue) {
   type::F32 f32;
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>(""));
+  expr.push_back(create<IdentifierExpression>(mod.RegisterSymbol(""), ""));
 
   TypeConstructorExpression t(&f32, expr);
   EXPECT_FALSE(t.IsValid());
@@ -108,14 +114,17 @@
   type::F32 f32;
   type::Vector vec(&f32, 3);
   ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr_1"));
-  expr.push_back(create<IdentifierExpression>("expr_2"));
-  expr.push_back(create<IdentifierExpression>("expr_3"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr_1"), "expr_1"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr_2"), "expr_2"));
+  expr.push_back(
+      create<IdentifierExpression>(mod.RegisterSymbol("expr_3"), "expr_3"));
 
   TypeConstructorExpression t(&vec, expr);
   std::ostringstream out;
   t.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  TypeConstructor[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  TypeConstructor[not set]{
     __vec_3__f32
     Identifier[not set]{expr_1}
     Identifier[not set]{expr_2}

diff --git a/src/ast/unary_op_expression_test.cc b/src/ast/unary_op_expression_test.cc
index 5e3ec1f..532d8cb 100644
--- a/src/ast/unary_op_expression_test.cc
+++ b/src/ast/unary_op_expression_test.cc

@@ -26,7 +26,8 @@
 using UnaryOpExpressionTest = TestHelper;
 
 TEST_F(UnaryOpExpressionTest, Creation) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
 
   UnaryOpExpression u(UnaryOp::kNot, ident);
   EXPECT_EQ(u.op(), UnaryOp::kNot);
@@ -34,7 +35,8 @@
 }
 
 TEST_F(UnaryOpExpressionTest, Creation_WithSource) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   UnaryOpExpression u(Source{Source::Location{20, 2}}, UnaryOp::kNot, ident);
   auto src = u.source();
   EXPECT_EQ(src.range.begin.line, 20u);
@@ -42,13 +44,15 @@
 }
 
 TEST_F(UnaryOpExpressionTest, IsUnaryOp) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   UnaryOpExpression u(UnaryOp::kNot, ident);
   EXPECT_TRUE(u.Is<UnaryOpExpression>());
 }
 
 TEST_F(UnaryOpExpressionTest, IsValid) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   UnaryOpExpression u(UnaryOp::kNot, ident);
   EXPECT_TRUE(u.IsValid());
 }
@@ -59,17 +63,18 @@
 }
 
 TEST_F(UnaryOpExpressionTest, IsValid_InvalidExpression) {
-  auto* ident = create<IdentifierExpression>("");
+  auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
   UnaryOpExpression u(UnaryOp::kNot, ident);
   EXPECT_FALSE(u.IsValid());
 }
 
 TEST_F(UnaryOpExpressionTest, ToStr) {
-  auto* ident = create<IdentifierExpression>("ident");
+  auto* ident =
+      create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
   UnaryOpExpression u(UnaryOp::kNot, ident);
   std::ostringstream out;
   u.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  UnaryOp[not set]{
+  EXPECT_EQ(demangle(out.str()), R"(  UnaryOp[not set]{
     not
     Identifier[not set]{ident}
   }

diff --git a/src/ast/variable_test.cc b/src/ast/variable_test.cc
index 5465883..ac95d69 100644
--- a/src/ast/variable_test.cc
+++ b/src/ast/variable_test.cc

@@ -84,7 +84,7 @@
              StorageClass::kNone,
              &t,
              false,
-             create<IdentifierExpression>("ident"),
+             create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"),
              ast::VariableDecorationList{}};
   EXPECT_TRUE(v.IsValid());
 }
@@ -115,7 +115,7 @@
              StorageClass::kNone,
              &t,
              false,
-             create<IdentifierExpression>(""),
+             create<IdentifierExpression>(mod.RegisterSymbol(""), ""),
              ast::VariableDecorationList{}};
   EXPECT_FALSE(v.IsValid());
 }
@@ -162,16 +162,17 @@
 
 TEST_F(VariableTest, Decorated_to_str) {
   type::F32 t;
-  auto* var = create<Variable>(Source{}, "my_var", StorageClass::kFunction, &t,
-                               false, create<IdentifierExpression>("expr"),
-                               VariableDecorationList{
-                                   create<BindingDecoration>(2, Source{}),
-                                   create<SetDecoration>(1, Source{}),
-                               });
+  auto* var = create<Variable>(
+      Source{}, "my_var", StorageClass::kFunction, &t, false,
+      create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"),
+      VariableDecorationList{
+          create<BindingDecoration>(2, Source{}),
+          create<SetDecoration>(1, Source{}),
+      });
 
   std::ostringstream out;
   var->to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Variable{
+  EXPECT_EQ(demangle(out.str()), R"(  Variable{
     Decorations{
       BindingDecoration{2}
       SetDecoration{1}

diff --git a/src/inspector/inspector_test.cc b/src/inspector/inspector_test.cc
index fbf24e5..5a40623 100644
--- a/src/inspector/inspector_test.cc
+++ b/src/inspector/inspector_test.cc

@@ -98,7 +98,8 @@
       std::string callee,
       ast::FunctionDecorationList decorations = {}) {
     auto* body = create<ast::BlockStatement>();
-    auto* ident_expr = create<ast::IdentifierExpression>(callee);
+    auto* ident_expr = create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(callee), callee);
     auto* call_expr =
         create<ast::CallExpression>(ident_expr, ast::ExpressionList());
     body->append(create<ast::CallStatement>(call_expr));
@@ -152,8 +153,8 @@
       std::string in, out;
       std::tie(in, out) = inout;
       body->append(create<ast::AssignmentStatement>(
-          create<ast::IdentifierExpression>(out),
-          create<ast::IdentifierExpression>(in)));
+          create<ast::IdentifierExpression>(mod()->RegisterSymbol(out), out),
+          create<ast::IdentifierExpression>(mod()->RegisterSymbol(in), in)));
     }
     body->append(create<ast::ReturnStatement>(Source{}));
     return create<ast::Function>(Source{}, mod()->RegisterSymbol(name), name,
@@ -179,10 +180,11 @@
       std::string in, out;
       std::tie(in, out) = inout;
       body->append(create<ast::AssignmentStatement>(
-          create<ast::IdentifierExpression>(out),
-          create<ast::IdentifierExpression>(in)));
+          create<ast::IdentifierExpression>(mod()->RegisterSymbol(out), out),
+          create<ast::IdentifierExpression>(mod()->RegisterSymbol(in), in)));
     }
-    auto* ident_expr = create<ast::IdentifierExpression>(callee);
+    auto* ident_expr = create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(callee), callee);
     auto* call_expr =
         create<ast::CallExpression>(ident_expr, ast::ExpressionList());
     body->append(create<ast::CallStatement>(call_expr));
@@ -442,10 +444,14 @@
       std::tie(member_idx, member_type) = member;
       std::string member_name = StructMemberName(member_idx, member_type);
       body->append(create<ast::AssignmentStatement>(
-          create<ast::IdentifierExpression>("local" + member_name),
+          create<ast::IdentifierExpression>(
+              mod()->RegisterSymbol("local" + member_name),
+              "local" + member_name),
           create<ast::MemberAccessorExpression>(
-              create<ast::IdentifierExpression>(struct_name),
-              create<ast::IdentifierExpression>(member_name))));
+              create<ast::IdentifierExpression>(
+                  mod()->RegisterSymbol(struct_name), struct_name),
+              create<ast::IdentifierExpression>(
+                  mod()->RegisterSymbol(member_name), member_name))));
     }
 
     body->append(create<ast::ReturnStatement>(Source{}));
@@ -581,14 +587,21 @@
     body->append(create<ast::VariableDeclStatement>(call_result));
 
     ast::ExpressionList call_params;
-    call_params.push_back(create<ast::IdentifierExpression>(texture_name));
-    call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
-    call_params.push_back(create<ast::IdentifierExpression>(coords_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(texture_name), texture_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(sampler_name), sampler_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(coords_name), coords_name));
     auto* call_expr = create<ast::CallExpression>(
-        create<ast::IdentifierExpression>("textureSample"), call_params);
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("textureSample"), "textureSample"),
+        call_params);
 
     body->append(create<ast::AssignmentStatement>(
-        create<ast::IdentifierExpression>("sampler_result"), call_expr));
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("sampler_result"), "sampler_result"),
+        call_expr));
     body->append(create<ast::ReturnStatement>(Source{}));
 
     return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@@ -628,15 +641,23 @@
     body->append(create<ast::VariableDeclStatement>(call_result));
 
     ast::ExpressionList call_params;
-    call_params.push_back(create<ast::IdentifierExpression>(texture_name));
-    call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
-    call_params.push_back(create<ast::IdentifierExpression>(coords_name));
-    call_params.push_back(create<ast::IdentifierExpression>(array_index));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(texture_name), texture_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(sampler_name), sampler_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(coords_name), coords_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(array_index), array_index));
     auto* call_expr = create<ast::CallExpression>(
-        create<ast::IdentifierExpression>("textureSample"), call_params);
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("textureSample"), "textureSample"),
+        call_params);
 
     body->append(create<ast::AssignmentStatement>(
-        create<ast::IdentifierExpression>("sampler_result"), call_expr));
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("sampler_result"), "sampler_result"),
+        call_expr));
     body->append(create<ast::ReturnStatement>(Source{}));
 
     return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@@ -677,15 +698,24 @@
     body->append(create<ast::VariableDeclStatement>(call_result));
 
     ast::ExpressionList call_params;
-    call_params.push_back(create<ast::IdentifierExpression>(texture_name));
-    call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
-    call_params.push_back(create<ast::IdentifierExpression>(coords_name));
-    call_params.push_back(create<ast::IdentifierExpression>(depth_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(texture_name), texture_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(sampler_name), sampler_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(coords_name), coords_name));
+    call_params.push_back(create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(depth_name), depth_name));
     auto* call_expr = create<ast::CallExpression>(
-        create<ast::IdentifierExpression>("textureSampleCompare"), call_params);
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("textureSampleCompare"),
+            "textureSampleCompare"),
+        call_params);
 
     body->append(create<ast::AssignmentStatement>(
-        create<ast::IdentifierExpression>("sampler_result"), call_expr));
+        create<ast::IdentifierExpression>(
+            mod()->RegisterSymbol("sampler_result"), "sampler_result"),
+        call_expr));
     body->append(create<ast::ReturnStatement>(Source{}));
 
     return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@@ -1507,7 +1537,8 @@
   AddReferenceFunc("ub_baz_func", "ub_baz");
 
   auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
-    auto* ident_expr = create<ast::IdentifierExpression>(callee);
+    auto* ident_expr = create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(callee), callee);
     auto* call_expr =
         create<ast::CallExpression>(ident_expr, ast::ExpressionList());
     body->append(create<ast::CallStatement>(call_expr));
@@ -1654,7 +1685,8 @@
   AddReferenceFunc("sb_baz_func", "sb_baz");
 
   auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
-    auto* ident_expr = create<ast::IdentifierExpression>(callee);
+    auto* ident_expr = create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(callee), callee);
     auto* call_expr =
         create<ast::CallExpression>(ident_expr, ast::ExpressionList());
     body->append(create<ast::CallStatement>(call_expr));
@@ -1828,7 +1860,8 @@
   AddReferenceFunc("sb_baz_func", "sb_baz");
 
   auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
-    auto* ident_expr = create<ast::IdentifierExpression>(callee);
+    auto* ident_expr = create<ast::IdentifierExpression>(
+        mod()->RegisterSymbol(callee), callee);
     auto* call_expr =
         create<ast::CallExpression>(ident_expr, ast::ExpressionList());
     body->append(create<ast::CallStatement>(call_expr));

diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index eddd2ad..08a1c6d 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc

@@ -689,7 +689,8 @@
   // as the statement block at the top of the stack.
   const auto& top = statements_stack_.back();
 
-  auto* cond = create<ast::IdentifierExpression>(guard_name);
+  auto* cond = create<ast::IdentifierExpression>(
+      ast_module_.RegisterSymbol(guard_name), guard_name);
   auto* body = create<ast::BlockStatement>();
   AddStatement(
       create<ast::IfStatement>(Source{}, cond, body, ast::ElseStatementList{}));
@@ -1891,9 +1892,11 @@
     return {};
   }
   if (identifier_values_.count(id) || parser_impl_.IsScalarSpecConstant(id)) {
+    auto name = namer_.Name(id);
     return TypedExpression{
         parser_impl_.ConvertType(def_use_mgr_->GetDef(id)->type_id()),
-        create<ast::IdentifierExpression>(namer_.Name(id))};
+        create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name),
+                                          name)};
   }
   if (singly_used_values_.count(id)) {
     auto expr = std::move(singly_used_values_[id]);
@@ -1910,11 +1913,13 @@
     return {};
   }
   switch (inst->opcode()) {
-    case SpvOpVariable:
+    case SpvOpVariable: {
       // This occurs for module-scope variables.
-      return TypedExpression{
-          parser_impl_.ConvertType(inst->type_id()),
-          create<ast::IdentifierExpression>(namer_.Name(inst->result_id()))};
+      auto name = namer_.Name(inst->result_id());
+      return TypedExpression{parser_impl_.ConvertType(inst->type_id()),
+                             create<ast::IdentifierExpression>(
+                                 ast_module_.RegisterSymbol(name), name)};
+    }
     default:
       break;
   }
@@ -2579,7 +2584,9 @@
         }
         // Signal an exit from the branch.
         return create<ast::AssignmentStatement>(
-            create<ast::IdentifierExpression>(flow_guard), MakeFalse());
+            create<ast::IdentifierExpression>(
+                ast_module_.RegisterSymbol(flow_guard), flow_guard),
+            MakeFalse());
       }
 
       // For an unconditional branch, the break out to an if-selection
@@ -2733,7 +2740,9 @@
       const auto var_name = GetDefInfo(assignment.phi_id)->phi_var;
       auto expr = MakeExpression(assignment.value);
       AddStatement(create<ast::AssignmentStatement>(
-          create<ast::IdentifierExpression>(var_name), expr.expr));
+          create<ast::IdentifierExpression>(
+              ast_module_.RegisterSymbol(var_name), var_name),
+          expr.expr));
     }
   }
 
@@ -2766,12 +2775,13 @@
   const auto result_id = inst.result_id();
   const auto* def_info = GetDefInfo(result_id);
   if (def_info && def_info->requires_hoisted_def) {
+    auto name = namer_.Name(result_id);
     // Emit an assignment of the expression to the hoisted variable.
-    AddStatementForInstruction(
-        create<ast::AssignmentStatement>(
-            create<ast::IdentifierExpression>(namer_.Name(result_id)),
-            ast_expr.expr),
-        inst);
+    AddStatementForInstruction(create<ast::AssignmentStatement>(
+                                   create<ast::IdentifierExpression>(
+                                       ast_module_.RegisterSymbol(name), name),
+                                   ast_expr.expr),
+                               inst);
     return true;
   }
   return EmitConstDefinition(inst, ast_expr);
@@ -2861,9 +2871,10 @@
     }
     case SpvOpPhi: {
       // Emit a read from the associated state variable.
-      TypedExpression expr{
-          parser_impl_.ConvertType(inst.type_id()),
-          create<ast::IdentifierExpression>(def_info->phi_var)};
+      TypedExpression expr{parser_impl_.ConvertType(inst.type_id()),
+                           create<ast::IdentifierExpression>(
+                               ast_module_.RegisterSymbol(def_info->phi_var),
+                               def_info->phi_var)};
       return EmitConstDefOrWriteToHoistedVar(inst, expr);
     }
     case SpvOpFunctionCall:
@@ -2916,7 +2927,9 @@
     ast::ExpressionList params;
     params.emplace_back(MakeOperand(inst, 0).expr);
     return {ast_type, create<ast::CallExpression>(
-                          create<ast::IdentifierExpression>(unary_builtin_name),
+                          create<ast::IdentifierExpression>(
+                              ast_module_.RegisterSymbol(unary_builtin_name),
+                              unary_builtin_name),
                           std::move(params))};
   }
 
@@ -3017,7 +3030,8 @@
     return {};
   }
 
-  auto* func = create<ast::IdentifierExpression>(name);
+  auto* func =
+      create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
   ast::ExpressionList operands;
   ast::type::Type* first_operand_type = nullptr;
   // All parameters to GLSL.std.450 extended instructions are IDs.
@@ -3042,17 +3056,21 @@
     return nullptr;
   }
   const char* names[] = {"x", "y", "z", "w"};
-  return create<ast::IdentifierExpression>(names[i & 3]);
+  return create<ast::IdentifierExpression>(
+      ast_module_.RegisterSymbol(names[i & 3]), names[i & 3]);
 }
 
 ast::IdentifierExpression* FunctionEmitter::PrefixSwizzle(uint32_t n) {
   switch (n) {
     case 1:
-      return create<ast::IdentifierExpression>("x");
+      return create<ast::IdentifierExpression>(ast_module_.RegisterSymbol("x"),
+                                               "x");
     case 2:
-      return create<ast::IdentifierExpression>("xy");
+      return create<ast::IdentifierExpression>(ast_module_.RegisterSymbol("xy"),
+                                               "xy");
     case 3:
-      return create<ast::IdentifierExpression>("xyz");
+      return create<ast::IdentifierExpression>(
+          ast_module_.RegisterSymbol("xyz"), "xyz");
     default:
       break;
   }
@@ -3121,8 +3139,10 @@
       first_index = first_index + 1;
       // Replace the gl_PerVertex reference with the gl_Position reference
       ptr_ty_id = builtin_position_info.member_pointer_type_id;
-      current_expr.expr =
-          create<ast::IdentifierExpression>(namer_.Name(base_id));
+
+      auto name = namer_.Name(base_id);
+      current_expr.expr = create<ast::IdentifierExpression>(
+          ast_module_.RegisterSymbol(name), name);
       current_expr.type = parser_impl_.ConvertType(ptr_ty_id);
     }
   }
@@ -3212,8 +3232,10 @@
                  << pointee_type_id << " having " << num_members << " members";
           return {};
         }
+        auto name =
+            namer_.GetMemberName(pointee_type_id, uint32_t(index_const_val));
         auto* member_access = create<ast::IdentifierExpression>(
-            namer_.GetMemberName(pointee_type_id, uint32_t(index_const_val)));
+            ast_module_.RegisterSymbol(name), name);
 
         next_expr = create<ast::MemberAccessorExpression>(current_expr.expr,
                                                           member_access);
@@ -3331,8 +3353,9 @@
                  << current_type_id << " having " << num_members << " members";
           return {};
         }
+        auto name = namer_.GetMemberName(current_type_id, uint32_t(index_val));
         auto* member_access = create<ast::IdentifierExpression>(
-            namer_.GetMemberName(current_type_id, uint32_t(index_val)));
+            ast_module_.RegisterSymbol(name), name);
 
         next_expr = create<ast::MemberAccessorExpression>(current_expr.expr,
                                                           member_access);
@@ -3712,8 +3735,9 @@
 
 bool FunctionEmitter::EmitFunctionCall(const spvtools::opt::Instruction& inst) {
   // We ignore function attributes such as Inline, DontInline, Pure, Const.
-  auto* function = create<ast::IdentifierExpression>(
-      namer_.Name(inst.GetSingleWordInOperand(0)));
+  auto name = namer_.Name(inst.GetSingleWordInOperand(0));
+  auto* function =
+      create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
 
   ast::ExpressionList params;
   for (uint32_t iarg = 1; iarg < inst.NumInOperands(); ++iarg) {
@@ -3739,7 +3763,9 @@
   const auto intrinsic = GetIntrinsic(inst.opcode());
   std::ostringstream ss;
   ss << intrinsic;
-  auto* ident = create<ast::IdentifierExpression>(ss.str());
+  auto name = ss.str();
+  auto* ident =
+      create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
   ident->set_intrinsic(intrinsic);
 
   ast::ExpressionList params;
@@ -3781,9 +3807,11 @@
     params.push_back(operand2.expr);
     // The condition goes last.
     params.push_back(condition.expr);
-    return {operand1.type, create<ast::CallExpression>(
-                               create<ast::IdentifierExpression>("select"),
-                               std::move(params))};
+    return {operand1.type,
+            create<ast::CallExpression>(
+                create<ast::IdentifierExpression>(
+                    ast_module_.RegisterSymbol("select"), "select"),
+                std::move(params))};
   }
   return {};
 }
@@ -3813,8 +3841,9 @@
     return Fail() << "internal error: couldn't find image for "
                   << inst.PrettyPrint();
   }
-  params.push_back(
-      create<ast::IdentifierExpression>(namer_.Name(image->result_id())));
+  auto name = namer_.Name(image->result_id());
+  params.push_back(create<ast::IdentifierExpression>(
+      ast_module_.RegisterSymbol(name), name));
 
   if (IsSampledImageAccess(inst.opcode())) {
     // Form the sampler operand.
@@ -3824,8 +3853,9 @@
       return Fail() << "internal error: couldn't find sampler for "
                     << inst.PrettyPrint();
     }
-    params.push_back(
-        create<ast::IdentifierExpression>(namer_.Name(sampler->result_id())));
+    auto param_name = namer_.Name(sampler->result_id());
+    params.push_back(create<ast::IdentifierExpression>(
+        ast_module_.RegisterSymbol(param_name), param_name));
   }
 
   ast::type::Pointer* texture_ptr_type =
@@ -3964,7 +3994,8 @@
                   << "): " << inst.PrettyPrint();
   }
 
-  auto* ident = create<ast::IdentifierExpression>(builtin_name);
+  auto* ident = create<ast::IdentifierExpression>(
+      ast_module_.RegisterSymbol(builtin_name), builtin_name);
   auto* call_expr = create<ast::CallExpression>(ident, std::move(params));
 
   if (inst.type_id() != 0) {

diff --git a/src/reader/spirv/function_arithmetic_test.cc b/src/reader/spirv/function_arithmetic_test.cc
index 415e0b1..b474a27 100644
--- a/src/reader/spirv/function_arithmetic_test.cc
+++ b/src/reader/spirv/function_arithmetic_test.cc

@@ -135,7 +135,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -147,7 +147,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_Int_Uint) {
@@ -162,7 +162,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -176,7 +176,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_Uint_Int) {
@@ -191,7 +191,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -205,7 +205,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_Uint_Uint) {
@@ -220,7 +220,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -236,7 +236,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_SignedVec_SignedVec) {
@@ -251,7 +251,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -267,7 +267,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_SignedVec_UnsignedVec) {
@@ -282,7 +282,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -300,7 +300,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_SignedVec) {
@@ -315,7 +315,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -333,7 +333,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_UnsignedVec) {
@@ -348,7 +348,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -368,7 +368,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, FNegate_Scalar) {
@@ -383,7 +383,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -395,7 +395,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryArithTest, FNegate_Vector) {
@@ -410,7 +410,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -426,7 +426,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 struct BinaryData {
@@ -474,7 +474,8 @@
      << GetParam().ast_type << "\n    {\n      Binary[not set]{"
      << "\n        " << GetParam().ast_lhs << "\n        " << GetParam().ast_op
      << "\n        " << GetParam().ast_rhs;
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
+      << assembly;
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -696,7 +697,7 @@
       << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -731,7 +732,7 @@
       << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -754,7 +755,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -842,7 +843,7 @@
       << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -877,7 +878,7 @@
       << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -900,7 +901,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -930,7 +931,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __vec_2__f32
@@ -942,7 +944,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, MatrixTimesScalar) {
@@ -959,7 +961,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __mat_2_2__f32
@@ -971,7 +974,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, VectorTimesMatrix) {
@@ -988,7 +991,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __mat_2_2__f32
@@ -1000,7 +1004,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, MatrixTimesVector) {
@@ -1017,7 +1021,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __mat_2_2__f32
@@ -1029,7 +1034,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, MatrixTimesMatrix) {
@@ -1046,7 +1051,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __mat_2_2__f32
@@ -1058,7 +1064,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, Dot) {
@@ -1075,7 +1081,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_3
     none
     __f32
@@ -1089,7 +1096,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvBinaryArithTestBasic, OuterProduct) {
@@ -1106,7 +1113,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_3
     none
     __mat_2_2__f32
@@ -1120,7 +1128,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 // TODO(dneto): OpSRem. Missing from WGSL

diff --git a/src/reader/spirv/function_bit_test.cc b/src/reader/spirv/function_bit_test.cc
index 3ed4f4e..3565456 100644
--- a/src/reader/spirv/function_bit_test.cc
+++ b/src/reader/spirv/function_bit_test.cc

@@ -163,7 +163,8 @@
      << GetParam().ast_type << "\n    {\n      Binary[not set]{"
      << "\n        " << GetParam().ast_lhs << "\n        " << GetParam().ast_op
      << "\n        " << GetParam().ast_rhs;
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
+      << assembly;
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -400,7 +401,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -412,7 +413,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_Int_Uint) {
@@ -427,7 +428,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -441,7 +442,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_Uint_Int) {
@@ -456,7 +457,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -470,7 +471,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_Uint_Uint) {
@@ -485,7 +486,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -497,7 +498,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_SignedVec_SignedVec) {
@@ -512,7 +513,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -528,7 +529,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_SignedVec_UnsignedVec) {
@@ -543,7 +544,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -561,7 +562,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryBitTest, Not_UnsignedVec_SignedVec) {
@@ -576,7 +577,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -594,7 +595,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 TEST_F(SpvUnaryBitTest, Not_UnsignedVec_UnsignedVec) {
   const auto assembly = CommonTypes() + R"(
@@ -608,7 +609,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -624,7 +625,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 std::string BitTestPreamble() {
@@ -663,7 +664,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -691,7 +692,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -721,7 +722,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -751,7 +752,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -779,7 +780,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -807,7 +808,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -837,7 +838,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -867,7 +868,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -895,7 +896,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -923,7 +924,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -953,7 +954,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -983,7 +984,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1011,7 +1012,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1039,7 +1040,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1069,7 +1070,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1099,7 +1100,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  const auto body = ToString(fe.ast_body());
+  const auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1

diff --git a/src/reader/spirv/function_call_test.cc b/src/reader/spirv/function_call_test.cc
index fabf819..ce9525a 100644
--- a/src/reader/spirv/function_call_test.cc
+++ b/src/reader/spirv/function_call_test.cc

@@ -48,18 +48,16 @@
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
   const auto module_ast_str = p->get_module().to_str();
   EXPECT_THAT(module_ast_str, Eq(R"(Module{
-  Function )" + p->get_module().GetSymbol("x_50").to_str() +
-                                 R"( -> __void
+  Function tint_symbol_1 -> __void
   ()
   {
     Return{}
   }
-  Function )" + p->get_module().GetSymbol("x_100").to_str() +
-                                 R"( -> __void
+  Function tint_symbol_2 -> __void
   ()
   {
     Call[not set]{
-      Identifier[not set]{x_50}
+      Identifier[not set]{tint_symbol_1}
       (
       )
     }
@@ -92,7 +90,8 @@
   {
     FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
     EXPECT_TRUE(fe.EmitBody());
-    EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+    EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+                HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -107,17 +106,17 @@
   }
 }
 Return{})"))
-        << ToString(fe.ast_body());
+        << ToString(p->get_module(), fe.ast_body());
   }
 
   {
     FunctionEmitter fe(p.get(), *spirv_function(p.get(), 50));
     EXPECT_TRUE(fe.EmitBody());
-    EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Return{
+    EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Return{
   {
     ScalarConstructor[not set]{42}
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
   }
 }
 
@@ -148,7 +147,8 @@
   {
     FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
     EXPECT_TRUE(fe.EmitBody()) << p->error();
-    EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+    EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+                HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_10
     function
@@ -178,16 +178,16 @@
   Identifier[not set]{x_1}
 }
 Return{})"))
-        << ToString(fe.ast_body());
+        << ToString(p->get_module(), fe.ast_body());
   }
   {
     FunctionEmitter fe(p.get(), *spirv_function(p.get(), 50));
     EXPECT_TRUE(fe.EmitBody()) << p->error();
-    EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Return{
+    EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Return{
   {
     ScalarConstructor[not set]{42}
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
   }
 }
 
@@ -218,8 +218,7 @@
   EXPECT_TRUE(p->error().empty());
   const auto module_ast_str = p->get_module().to_str();
   EXPECT_THAT(module_ast_str, HasSubstr(R"(Module{
-  Function )" + p->get_module().GetSymbol("x_50").to_str() +
-                                        R"( -> __u32
+  Function tint_symbol_3 -> __u32
   (
     VariableConst{
       x_51
@@ -236,9 +235,9 @@
     Return{
       {
         Binary[not set]{
-          Identifier[not set]{x_51}
+          Identifier[not set]{tint_symbol_1}
           add
-          Identifier[not set]{x_52}
+          Identifier[not set]{tint_symbol_2}
         }
       }
     }
@@ -254,7 +253,7 @@
         __u32
         {
           Call[not set]{
-            Identifier[not set]{x_50}
+            Identifier[not set]{tint_symbol_3}
             (
               ScalarConstructor[not set]{42}
               ScalarConstructor[not set]{84}

diff --git a/src/reader/spirv/function_cfg_test.cc b/src/reader/spirv/function_cfg_test.cc
index c94abd7..cc5bdf9 100644
--- a/src/reader/spirv/function_cfg_test.cc
+++ b/src/reader/spirv/function_cfg_test.cc

@@ -7361,7 +7361,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -7473,7 +7473,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -7600,7 +7600,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error() << assembly;
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -7791,7 +7791,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -7827,7 +7827,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -7875,7 +7875,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -7931,7 +7931,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -7998,7 +7998,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8070,7 +8070,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8134,7 +8134,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8219,7 +8219,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8309,7 +8309,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8364,7 +8364,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8415,7 +8415,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8458,7 +8458,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8509,7 +8509,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8574,7 +8574,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8648,7 +8648,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8720,7 +8720,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -8778,7 +8778,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -8838,7 +8838,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -8905,7 +8905,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -8979,7 +8979,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   If{
     (
@@ -9037,7 +9037,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -9086,7 +9086,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -9142,7 +9142,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -9204,7 +9204,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -9266,7 +9266,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -9319,7 +9319,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9364,7 +9364,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9418,7 +9418,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9478,7 +9478,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9544,7 +9544,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9615,7 +9615,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9687,7 +9687,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9757,7 +9757,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -9809,7 +9809,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Return{}
 )";
   ASSERT_EQ(expect, got);
@@ -9835,7 +9835,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -9875,7 +9875,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Return{}
 }
@@ -9905,7 +9905,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Return{
   {
     ScalarConstructor[not set]{2}
@@ -9944,7 +9944,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -10001,7 +10001,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Return{
     {
@@ -10031,7 +10031,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Discard{}
 )";
   ASSERT_EQ(expect, got);
@@ -10057,7 +10057,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -10097,7 +10097,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Discard{}
 }
@@ -10119,7 +10119,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Return{}
 )";
   ASSERT_EQ(expect, got);
@@ -10145,7 +10145,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -10185,7 +10185,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Return{}
 }
@@ -10215,7 +10215,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Return{
   {
     ScalarConstructor[not set]{0}
@@ -10249,7 +10249,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   continuing {
     Assignment{
@@ -10284,7 +10284,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -10321,7 +10321,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -10381,7 +10381,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -10452,7 +10452,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -10534,7 +10534,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   continuing {
     Assignment{
@@ -10576,7 +10576,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   Assignment{
     Identifier[not set]{var_1}
@@ -10630,7 +10630,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Loop{
   If{
     (
@@ -10699,7 +10699,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -10769,7 +10769,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -10812,7 +10812,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(If{
   (
     ScalarConstructor[not set]{false}
@@ -10864,7 +10864,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -10915,7 +10915,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11019,7 +11019,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11062,7 +11062,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11113,7 +11113,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11171,7 +11171,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11227,7 +11227,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11287,7 +11287,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11348,7 +11348,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11431,7 +11431,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11526,7 +11526,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11611,7 +11611,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11680,7 +11680,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11747,7 +11747,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11821,7 +11821,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -11890,7 +11890,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -11948,7 +11948,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12021,7 +12021,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12117,7 +12117,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12256,7 +12256,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12337,7 +12337,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12405,7 +12405,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12462,7 +12462,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12534,7 +12534,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12622,7 +12622,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12701,7 +12701,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -12789,7 +12789,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12886,7 +12886,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -12982,7 +12982,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -13091,7 +13091,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -13188,7 +13188,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -13269,7 +13269,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -13333,7 +13333,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{0}
@@ -13418,7 +13418,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -13509,7 +13509,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = R"(Assignment{
   Identifier[not set]{var_1}
   ScalarConstructor[not set]{1}
@@ -13578,7 +13578,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = "unhandled case";
   ASSERT_EQ(expect, got);
 }
@@ -13613,7 +13613,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto got = ToString(fe.ast_body());
+  auto got = ToString(p->get_module(), fe.ast_body());
   auto* expect = "unhandled case";
   ASSERT_EQ(expect, got);
 }

diff --git a/src/reader/spirv/function_composite_test.cc b/src/reader/spirv/function_composite_test.cc
index 0cc2cc8..2c4d356 100644
--- a/src/reader/spirv/function_composite_test.cc
+++ b/src/reader/spirv/function_composite_test.cc

@@ -86,7 +86,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -127,7 +128,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_Composite_Construct, Matrix) {
@@ -142,7 +143,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -168,7 +169,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_Composite_Construct, Array) {
@@ -183,7 +184,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -199,7 +200,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_Composite_Construct, Struct) {
@@ -214,7 +215,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -232,7 +233,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 using SpvParserTest_CompositeExtract = SpvParserTest;
@@ -249,7 +250,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -265,7 +266,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, Vector_IndexTooBigError) {
@@ -300,7 +301,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -312,7 +313,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, Matrix_IndexTooBigError) {
@@ -351,7 +352,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -366,7 +367,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, Array) {
@@ -385,7 +386,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -397,7 +398,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, RuntimeArray_IsError) {
@@ -436,7 +437,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -448,7 +449,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, Struct_DifferOnlyInMemberName) {
@@ -478,7 +479,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -490,8 +491,8 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+      << ToString(p->get_module(), fe.ast_body());
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_4
     none
@@ -503,7 +504,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CompositeExtract, Struct_IndexTooBigError) {
@@ -544,7 +545,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -565,7 +566,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 using SpvParserTest_CopyObject = SpvParserTest;
@@ -583,7 +584,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -602,7 +604,7 @@
       Identifier[not set]{x_1}
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_CopyObject, Pointer) {
@@ -621,7 +623,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -640,7 +643,7 @@
       Identifier[not set]{x_1}
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 using SpvParserTest_VectorShuffle = SpvParserTest;
@@ -661,7 +664,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __vec_4__u32
@@ -687,7 +691,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_UseBoth) {
@@ -703,7 +707,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __vec_4__u32
@@ -745,7 +750,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_AllOnesMapToNull) {
@@ -762,7 +767,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_10
     none
     __vec_2__u32
@@ -777,7 +783,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest_VectorShuffle, IndexTooBig_IsError) {

diff --git a/src/reader/spirv/function_conversion_test.cc b/src/reader/spirv/function_conversion_test.cc
index e95afa7..5499451 100644
--- a/src/reader/spirv/function_conversion_test.cc
+++ b/src/reader/spirv/function_conversion_test.cc

@@ -82,7 +82,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -93,7 +93,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, Bitcast_Vector) {
@@ -108,7 +108,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -123,7 +123,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertSToF_BadArg) {
@@ -238,7 +238,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __f32
@@ -249,7 +250,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromUnsigned) {
@@ -265,7 +266,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __f32
@@ -278,7 +280,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromSigned) {
@@ -294,7 +296,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__f32
@@ -305,7 +308,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromUnsigned) {
@@ -321,7 +324,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__f32
@@ -334,7 +338,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_BadArgType) {
@@ -383,7 +387,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __f32
@@ -396,7 +401,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromUnsigned) {
@@ -412,7 +417,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __f32
@@ -423,7 +429,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromSigned) {
@@ -439,7 +445,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__f32
@@ -452,7 +459,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromUnsigned) {
@@ -468,7 +475,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__f32
@@ -479,7 +487,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_BadArgType) {
@@ -529,7 +537,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __i32
@@ -540,7 +549,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToUnsigned) {
@@ -556,7 +565,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __u32
@@ -569,7 +579,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToSigned) {
@@ -585,7 +595,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__i32
@@ -596,7 +607,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToUnsigned) {
@@ -612,7 +623,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__u32
@@ -625,7 +637,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_BadArgType) {
@@ -675,7 +687,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __i32
@@ -688,7 +701,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToUnsigned) {
@@ -704,7 +717,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __u32
@@ -715,7 +729,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToSigned) {
@@ -731,7 +745,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__i32
@@ -744,7 +759,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToUnsigned) {
@@ -760,7 +775,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableConst{
     x_1
     none
     __vec_2__u32
@@ -771,7 +787,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 // TODO(dneto): OpSConvert // only if multiple widths

diff --git a/src/reader/spirv/function_glsl_std_450_test.cc b/src/reader/spirv/function_glsl_std_450_test.cc
index 4333cee..78f7932 100644
--- a/src/reader/spirv/function_glsl_std_450_test.cc
+++ b/src/reader/spirv/function_glsl_std_450_test.cc

@@ -183,7 +183,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -191,14 +191,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Float_Floating, Vector) {
@@ -212,7 +212,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -220,14 +220,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Scalar) {
@@ -241,7 +241,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -249,7 +249,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
           Identifier[not set]{f2}
@@ -257,7 +257,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Vector) {
@@ -271,7 +271,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -279,7 +279,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
           Identifier[not set]{v2f2}
@@ -287,7 +287,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Scalar) {
@@ -301,7 +301,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -309,14 +309,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Vector) {
@@ -330,7 +330,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -338,14 +338,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Scalar) {
@@ -359,7 +359,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -367,7 +367,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
           Identifier[not set]{f2}
@@ -375,7 +375,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Vector) {
@@ -389,7 +389,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -397,7 +397,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
           Identifier[not set]{v2f2}
@@ -405,7 +405,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Scalar) {
@@ -419,7 +419,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -427,7 +427,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
           Identifier[not set]{f2}
@@ -436,7 +436,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Vector) {
@@ -451,7 +451,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -459,7 +459,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
           Identifier[not set]{v2f2}
@@ -468,7 +468,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Scalar) {
@@ -482,7 +482,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -490,7 +490,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
           Identifier[not set]{u1}
@@ -498,7 +498,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Vector) {
@@ -513,7 +513,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -521,7 +521,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
           Identifier[not set]{v2u1}
@@ -529,7 +529,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Scalar) {
@@ -543,7 +543,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -551,7 +551,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{f1}
           Identifier[not set]{i1}
@@ -559,7 +559,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Vector) {
@@ -574,7 +574,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -582,7 +582,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2f1}
           Identifier[not set]{v2i1}
@@ -590,7 +590,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Float3_Float3Float3, Samples) {
@@ -605,7 +605,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -613,7 +613,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v3f1}
           Identifier[not set]{v3f2}
@@ -621,7 +621,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 INSTANTIATE_TEST_SUITE_P(Samples,
@@ -709,7 +709,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -717,14 +717,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{i1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Vector) {
@@ -739,7 +739,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -747,14 +747,14 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2i1}
         )
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Scalar) {
@@ -769,7 +769,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -777,7 +777,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{i1}
           Identifier[not set]{i2}
@@ -785,7 +785,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Vector) {
@@ -800,7 +800,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -808,7 +808,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2i1}
           Identifier[not set]{v2i2}
@@ -816,7 +816,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Scalar) {
@@ -831,7 +831,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -839,7 +839,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{i1}
           Identifier[not set]{i2}
@@ -848,7 +848,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Vector) {
@@ -863,7 +863,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -871,7 +871,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2i1}
           Identifier[not set]{v2i2}
@@ -880,7 +880,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 INSTANTIATE_TEST_SUITE_P(Samples,
@@ -907,7 +907,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -915,7 +915,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{u1}
           Identifier[not set]{u2}
@@ -923,7 +923,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Vector) {
@@ -938,7 +938,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -946,7 +946,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2u1}
           Identifier[not set]{v2u2}
@@ -954,7 +954,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Scalar) {
@@ -968,7 +968,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -976,7 +976,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{u1}
           Identifier[not set]{u2}
@@ -985,7 +985,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Vector) {
@@ -1000,7 +1000,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -1008,7 +1008,7 @@
     {
       Call[not set]{
         Identifier[not set]{)" + GetParam().wgsl_func +
-                                                 R"(}
+                                                                  R"(}
         (
           Identifier[not set]{v2u1}
           Identifier[not set]{v2u2}
@@ -1017,7 +1017,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 INSTANTIATE_TEST_SUITE_P(Samples,
@@ -1043,7 +1043,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1095,7 +1095,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1153,7 +1153,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1211,7 +1211,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1271,7 +1271,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1329,7 +1329,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1
@@ -1387,7 +1387,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  auto body = ToString(fe.ast_body());
+  auto body = ToString(p->get_module(), fe.ast_body());
   EXPECT_THAT(body, HasSubstr(R"(
   VariableConst{
     x_1

diff --git a/src/reader/spirv/function_logical_test.cc b/src/reader/spirv/function_logical_test.cc
index 1630a1f..355c223 100644
--- a/src/reader/spirv/function_logical_test.cc
+++ b/src/reader/spirv/function_logical_test.cc

@@ -206,7 +206,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -218,7 +218,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvUnaryLogicalTest, LogicalNot_Vector) {
@@ -233,7 +233,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -249,7 +249,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 struct BinaryData {
@@ -296,7 +296,8 @@
      << GetParam().ast_type << "\n    {\n      Binary[not set]{"
      << "\n        " << GetParam().ast_lhs << "\n        " << GetParam().ast_op
      << "\n        " << GetParam().ast_rhs;
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
+      << assembly;
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -701,7 +702,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -717,7 +718,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordEqual_Vector) {
@@ -732,7 +733,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -756,7 +757,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordNotEqual_Scalar) {
@@ -771,7 +772,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -787,7 +788,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordNotEqual_Vector) {
@@ -802,7 +803,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -826,7 +827,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordLessThan_Scalar) {
@@ -841,7 +842,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -857,7 +858,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordLessThan_Vector) {
@@ -872,7 +873,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -896,7 +897,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordLessThanEqual_Scalar) {
@@ -911,7 +912,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -927,7 +928,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordLessThanEqual_Vector) {
@@ -942,7 +943,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -966,7 +967,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordGreaterThan_Scalar) {
@@ -981,7 +982,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -997,7 +998,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordGreaterThan_Vector) {
@@ -1012,7 +1013,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -1036,7 +1037,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Scalar) {
@@ -1051,7 +1052,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -1067,7 +1068,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Vector) {
@@ -1082,7 +1083,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -1106,7 +1107,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, Select_BoolCond_BoolParams) {
@@ -1121,7 +1122,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1137,7 +1139,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, Select_BoolCond_IntScalarParams) {
@@ -1152,7 +1154,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1168,7 +1171,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, Select_BoolCond_FloatScalarParams) {
@@ -1183,7 +1186,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1199,7 +1203,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, Select_BoolCond_VectorParams) {
@@ -1214,7 +1218,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1238,7 +1243,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvFUnordTest, Select_VecBoolCond_VectorParams) {
@@ -1253,7 +1258,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1281,7 +1287,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 using SpvLogicalTest = SpvParserTestBase<::testing::Test>;
@@ -1298,7 +1304,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1316,7 +1323,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvLogicalTest, All) {
@@ -1331,7 +1338,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1349,7 +1357,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvLogicalTest, IsNan_Scalar) {
@@ -1364,7 +1372,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1378,7 +1387,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvLogicalTest, IsNan_Vector) {
@@ -1393,7 +1402,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1411,7 +1421,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvLogicalTest, IsInf_Scalar) {
@@ -1426,7 +1436,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1440,7 +1451,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvLogicalTest, IsInf_Vector) {
@@ -1455,7 +1466,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1473,7 +1485,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 // TODO(dneto): Kernel-guarded instructions.

diff --git a/src/reader/spirv/function_memory_test.cc b/src/reader/spirv/function_memory_test.cc
index 86e5189..bda6e9a 100644
--- a/src/reader/spirv/function_memory_test.cc
+++ b/src/reader/spirv/function_memory_test.cc

@@ -50,7 +50,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{true}
 }
@@ -82,7 +82,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{42}
 }
@@ -110,7 +110,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{42}
 }
@@ -138,7 +138,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{42.000000}
 }
@@ -167,7 +167,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_2
     none
@@ -196,7 +196,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_2
     none
@@ -237,7 +238,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_2
     none
@@ -274,7 +276,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{42}
 })"));
@@ -341,13 +343,13 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   MemberAccessor[not set]{
     Identifier[not set]{myvar}
     Identifier[not set]{z}
   }
   ScalarConstructor[not set]{42}
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_AccessChain_VectorConstOutOfBounds) {
@@ -404,7 +406,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   ArrayAccessor[not set]{
     Identifier[not set]{myvar}
     Identifier[not set]{x_11}
@@ -441,7 +443,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   ArrayAccessor[not set]{
     Identifier[not set]{myvar}
     ScalarConstructor[not set]{2}
@@ -484,7 +486,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   ArrayAccessor[not set]{
     Identifier[not set]{myvar}
     ScalarConstructor[not set]{2}
@@ -526,7 +528,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   MemberAccessor[not set]{
     Identifier[not set]{myvar}
     Identifier[not set]{age}
@@ -574,7 +576,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   MemberAccessor[not set]{
     Identifier[not set]{myvar}
     Identifier[not set]{age}
@@ -587,7 +589,7 @@
     Identifier[not set]{ancientness}
   }
   ScalarConstructor[not set]{420.000000}
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_AccessChain_StructNonConstIndex) {
@@ -684,7 +686,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   ArrayAccessor[not set]{
     MemberAccessor[not set]{
       Identifier[not set]{myvar}
@@ -724,7 +726,7 @@
       << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   MemberAccessor[not set]{
     ArrayAccessor[not set]{
       Identifier[not set]{myvar}
@@ -832,7 +834,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   MemberAccessor[not set]{
     Identifier[not set]{myvar}
     Identifier[not set]{field0}
@@ -848,7 +850,7 @@
     ScalarConstructor[not set]{1}
   }
   ScalarConstructor[not set]{0}
-})")) << ToString(fe.ast_body())
+})")) << ToString(p->get_module(), fe.ast_body())
       << p->error();
 }
 
@@ -871,7 +873,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
   ArrayAccessor[not set]{
     MemberAccessor[not set]{
       Identifier[not set]{myvar}
@@ -880,7 +882,7 @@
     ScalarConstructor[not set]{1}
   }
   ScalarConstructor[not set]{0}
-})")) << ToString(fe.ast_body())
+})")) << ToString(p->get_module(), fe.ast_body())
       << p->error();
 }
 
@@ -904,7 +906,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_2
     none
@@ -923,7 +926,7 @@
 Assignment{
   Identifier[not set]{x_2}
   ScalarConstructor[not set]{0}
-})")) << ToString(fe.ast_body())
+})")) << ToString(p->get_module(), fe.ast_body())
       << p->error();
 }
 
@@ -959,7 +962,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   Variable{
     x_2
     function
@@ -993,7 +997,7 @@
   ScalarConstructor[not set]{0}
 }
 Return{}
-)")) << ToString(fe.ast_body())
+)")) << ToString(p->get_module(), fe.ast_body())
      << p->error();
 }
 

diff --git a/src/reader/spirv/function_misc_test.cc b/src/reader/spirv/function_misc_test.cc
index e215fdd..2558e49 100644
--- a/src/reader/spirv/function_misc_test.cc
+++ b/src/reader/spirv/function_misc_test.cc

@@ -68,7 +68,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_11
     none
@@ -107,7 +108,7 @@
       ScalarConstructor[not set]{0.000000}
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Vector) {
@@ -128,7 +129,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_11
     none
@@ -169,7 +171,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Matrix) {
@@ -188,7 +190,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_11
     none
@@ -209,7 +212,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Array) {
@@ -229,7 +232,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_11
     none
@@ -242,7 +246,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Struct) {
@@ -261,7 +265,8 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   VariableConst{
     x_11
     none
@@ -276,7 +281,7 @@
       }
     }
   }
-})")) << ToString(fe.ast_body());
+})")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTestMiscInstruction, OpNop) {
@@ -292,8 +297,8 @@
       << p->error() << assembly;
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Return{}
-)")) << ToString(fe.ast_body());
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Return{}
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 // Test swizzle generation.
@@ -324,7 +329,8 @@
     ASSERT_NE(result, nullptr);
     std::ostringstream ss;
     result->to_str(ss, 0);
-    EXPECT_THAT(ss.str(), Eq(GetParam().expected_expr));
+    auto str = Demangler().Demangle(p->get_module(), ss.str());
+    EXPECT_THAT(str, Eq(GetParam().expected_expr));
   } else {
     EXPECT_EQ(result, nullptr);
     EXPECT_FALSE(fe.success());

diff --git a/src/reader/spirv/function_var_test.cc b/src/reader/spirv/function_var_test.cc
index b4c9461..74803fa 100644
--- a/src/reader/spirv/function_var_test.cc
+++ b/src/reader/spirv/function_var_test.cc

@@ -91,7 +91,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_1
     function
@@ -129,7 +130,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     a
     function
@@ -167,7 +169,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     a
     function
@@ -208,7 +211,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     a
     function
@@ -281,7 +285,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     a
     function
@@ -340,7 +345,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -354,7 +360,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_MatrixInitializer) {
@@ -378,7 +384,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -424,7 +431,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -438,7 +446,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias) {
@@ -458,7 +466,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -472,7 +481,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Null) {
@@ -491,7 +500,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -505,7 +515,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias_Null) {
@@ -525,7 +535,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -539,7 +550,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer) {
@@ -559,7 +570,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -578,7 +590,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer_Null) {
@@ -598,7 +610,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitFunctionVariables());
 
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              HasSubstr(R"(VariableDeclStatement{
   Variable{
     x_200
     function
@@ -617,7 +630,7 @@
     }
   }
 }
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest,
@@ -642,7 +655,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   Variable{
     x_25
     function
@@ -662,7 +676,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_CombinatorialValue_Immediate_UsedTwice) {
@@ -687,7 +701,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   Variable{
     x_25
     function
@@ -721,7 +736,7 @@
   Identifier[not set]{x_2}
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest,
@@ -757,7 +772,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   Variable{
     x_25
     function
@@ -795,7 +811,7 @@
   ScalarConstructor[not set]{2}
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(
@@ -854,7 +870,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Assignment{
   Identifier[not set]{x_1}
   ScalarConstructor[not set]{0}
 }
@@ -926,7 +942,7 @@
   ScalarConstructor[not set]{5}
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(
@@ -970,7 +986,8 @@
 
   // We don't hoist x_1 into its own mutable variable. It is emitted as
   // a const definition.
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1002,7 +1019,7 @@
   Identifier[not set]{x_3}
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest,
@@ -1053,7 +1070,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(If{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(If{
   (
     ScalarConstructor[not set]{true}
   )
@@ -1092,7 +1109,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(
@@ -1138,7 +1155,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(If{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(If{
   (
     ScalarConstructor[not set]{true}
   )
@@ -1179,7 +1196,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest,
@@ -1219,7 +1236,8 @@
 
   // We don't hoist x_1 into its own mutable variable. It is emitted as
   // a const definition.
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   VariableConst{
     x_1
     none
@@ -1247,7 +1265,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_Phi_SingleBlockLoopIndex) {
@@ -1291,7 +1309,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Loop{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Loop{
   VariableDeclStatement{
     Variable{
       x_2_phi
@@ -1386,7 +1404,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_Phi_MultiBlockLoopIndex) {
@@ -1433,7 +1451,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Loop{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Loop{
   VariableDeclStatement{
     Variable{
       x_2_phi
@@ -1541,7 +1559,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_Phi_ValueFromLoopBodyAndContinuing) {
@@ -1589,7 +1607,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   VariableConst{
     x_101
     none
@@ -1707,7 +1726,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body())
+)")) << ToString(p->get_module(), fe.ast_body())
      << assembly;
 }
 
@@ -1757,7 +1776,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   VariableConst{
     x_101
     none
@@ -1831,7 +1851,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_Phi_FromHeaderAndThen) {
@@ -1877,7 +1897,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   VariableConst{
     x_101
     none
@@ -1946,7 +1967,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 TEST_F(SpvParserTest, EmitStatement_UseInPhiCountsAsUse) {
@@ -1983,7 +2004,8 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
 
-  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
+              Eq(R"(VariableDeclStatement{
   Variable{
     x_101_phi
     function
@@ -2043,7 +2065,7 @@
   }
 }
 Return{}
-)")) << ToString(fe.ast_body());
+)")) << ToString(p->get_module(), fe.ast_body());
 }
 
 }  // namespace

diff --git a/src/reader/spirv/parser_impl_function_decl_test.cc b/src/reader/spirv/parser_impl_function_decl_test.cc
index dab5f3a..ff60523 100644
--- a/src/reader/spirv/parser_impl_function_decl_test.cc
+++ b/src/reader/spirv/parser_impl_function_decl_test.cc

@@ -199,10 +199,10 @@
   )"));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
-  const auto module_ast = p->get_module().to_str();
+  const auto module_ast =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module_ast, HasSubstr(R"(
-  Function )" + p->get_module().GetSymbol("leaf").to_str() +
-                                    R"( -> __u32
+  Function leaf -> __u32
   ()
   {
     Return{
@@ -211,8 +211,7 @@
       }
     }
   }
-  Function )" + p->get_module().GetSymbol("branch").to_str() +
-                                    R"( -> __u32
+  Function branch -> __u32
   ()
   {
     VariableDeclStatement{
@@ -235,8 +234,7 @@
       }
     }
   }
-  Function )" + p->get_module().GetSymbol("root").to_str() +
-                                    R"( -> __void
+  Function root -> __void
   ()
   {
     VariableDeclStatement{

diff --git a/src/reader/spirv/parser_impl_handle_test.cc b/src/reader/spirv/parser_impl_handle_test.cc
index 7c3fc65..bed8be6 100644
--- a/src/reader/spirv/parser_impl_handle_test.cc
+++ b/src/reader/spirv/parser_impl_handle_test.cc

@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "gmock/gmock.h"
+#include "src/demangler.h"
 #include "src/reader/spirv/function.h"
 #include "src/reader/spirv/parser_impl.h"
 #include "src/reader/spirv/parser_impl_test_helper.h"
@@ -1128,7 +1129,8 @@
   auto p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
   EXPECT_TRUE(p->error().empty()) << p->error();
-  const auto module = p->module().to_str();
+  const auto module =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module, HasSubstr(GetParam().var_decl)) << module;
 }
 
@@ -1300,7 +1302,8 @@
   auto p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
   EXPECT_TRUE(p->error().empty()) << p->error();
-  const auto module = p->module().to_str();
+  const auto module =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module, HasSubstr(GetParam().var_decl))
       << "DECLARATIONS ARE BAD " << module;
   EXPECT_THAT(module, HasSubstr(GetParam().texture_builtin))
@@ -2373,7 +2376,8 @@
   auto p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
   EXPECT_TRUE(p->error().empty()) << p->error();
-  const auto module = p->module().to_str();
+  const auto module =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module, HasSubstr(GetParam().var_decl))
       << "DECLARATIONS ARE BAD " << module;
   EXPECT_THAT(module, HasSubstr(GetParam().texture_builtin))
@@ -3670,7 +3674,8 @@
       std::vector<std::string> result_strings;
       for (auto* expr : result) {
         ASSERT_NE(expr, nullptr);
-        result_strings.push_back(expr->str());
+        result_strings.push_back(
+            Demangler().Demangle(p->get_module(), expr->str()));
       }
       EXPECT_THAT(result_strings,
                   ::testing::ContainerEq(GetParam().expected_expressions));

diff --git a/src/reader/spirv/parser_impl_module_var_test.cc b/src/reader/spirv/parser_impl_module_var_test.cc
index be335f1..1554961 100644
--- a/src/reader/spirv/parser_impl_module_var_test.cc
+++ b/src/reader/spirv/parser_impl_module_var_test.cc

@@ -15,6 +15,7 @@
 #include <string>
 
 #include "gmock/gmock.h"
+#include "src/demangler.h"
 #include "src/reader/spirv/function.h"
 #include "src/reader/spirv/parser_impl.h"
 #include "src/reader/spirv/parser_impl_test_helper.h"
@@ -326,7 +327,8 @@
   auto p = parser(test::Assemble(assembly));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
-  const auto module_str = p->module().to_str();
+  const auto module_str =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module_str, HasSubstr(R"(
     Assignment{
       Identifier[not set]{gl_Position}
@@ -357,7 +359,8 @@
   auto p = parser(test::Assemble(assembly));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
-  const auto module_str = p->module().to_str();
+  const auto module_str =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module_str, HasSubstr(R"(
     Assignment{
       MemberAccessor[not set]{
@@ -388,7 +391,8 @@
   auto p = parser(test::Assemble(assembly));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
-  const auto module_str = p->module().to_str();
+  const auto module_str =
+      Demangler().Demangle(p->get_module(), p->get_module().to_str());
   EXPECT_THAT(module_str, HasSubstr(R"(
   {
     Assignment{
@@ -1654,7 +1658,7 @@
   FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
   EXPECT_TRUE(p->error().empty());
-  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
+  EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
   VariableConst{
     x_1
     none
@@ -1667,7 +1671,7 @@
       }
     }
   })"))
-      << ToString(fe.ast_body());
+      << ToString(p->get_module(), fe.ast_body());
 }
 
 }  // namespace

diff --git a/src/reader/spirv/parser_impl_test_helper.h b/src/reader/spirv/parser_impl_test_helper.h
index 0a915a8..0342e47 100644
--- a/src/reader/spirv/parser_impl_test_helper.h
+++ b/src/reader/spirv/parser_impl_test_helper.h

@@ -22,6 +22,7 @@
 
 #include "gtest/gtest.h"
 #include "source/opt/ir_context.h"
+#include "src/demangler.h"
 #include "src/reader/spirv/parser_impl.h"
 
 namespace tint {
@@ -59,12 +60,13 @@
 /// Returns the string dump of a function body.
 /// @param body the statement in the body
 /// @returnss the string dump of a function body.
-inline std::string ToString(const ast::BlockStatement* body) {
+inline std::string ToString(const ast::Module& mod,
+                            const ast::BlockStatement* body) {
   std::ostringstream outs;
   for (const auto* stmt : *body) {
     stmt->to_str(outs, 0);
   }
-  return outs.str();
+  return Demangler().Demangle(mod, outs.str());
 }
 
 }  // namespace spirv

diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index 04ff79b..a06ddfd 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc

@@ -2026,7 +2026,9 @@
     return Failure::kErrored;
 
   return create<ast::CallStatement>(create<ast::CallExpression>(
-      source, create<ast::IdentifierExpression>(name), std::move(params)));
+      source,
+      create<ast::IdentifierExpression>(module_.RegisterSymbol(name), name),
+      std::move(params)));
 }
 
 // break_stmt
@@ -2097,7 +2099,8 @@
   }
 
   if (match(Token::Type::kIdentifier))
-    return create<ast::IdentifierExpression>(t.source(), t.to_str());
+    return create<ast::IdentifierExpression>(
+        t.source(), module_.RegisterSymbol(t.to_str()), t.to_str());
 
   auto type = type_decl();
   if (type.errored)
@@ -2172,7 +2175,8 @@
 
     return postfix_expr(create<ast::MemberAccessorExpression>(
         ident.source, prefix,
-        create<ast::IdentifierExpression>(ident.source, ident.value)));
+        create<ast::IdentifierExpression>(
+            ident.source, module_.RegisterSymbol(ident.value), ident.value)));
   }
 
   return prefix;

diff --git a/src/transform/bound_array_accessors.cc b/src/transform/bound_array_accessors.cc
index 24d3ab6..ba5e954 100644
--- a/src/transform/bound_array_accessors.cc
+++ b/src/transform/bound_array_accessors.cc

@@ -135,7 +135,9 @@
         ctx->mod->create<ast::UintLiteral>(u32, size - 1)));
 
     auto* call_expr = ctx->mod->create<ast::CallExpression>(
-        ctx->mod->create<ast::IdentifierExpression>("min"), std::move(params));
+        ctx->mod->create<ast::IdentifierExpression>(
+            ctx->mod->RegisterSymbol("min"), "min"),
+        std::move(params));
     call_expr->set_result_type(u32);
 
     idx_expr = call_expr;

diff --git a/src/transform/emit_vertex_point_size.cc b/src/transform/emit_vertex_point_size.cc
index bc25ede..1c53e05 100644
--- a/src/transform/emit_vertex_point_size.cc
+++ b/src/transform/emit_vertex_point_size.cc

@@ -67,8 +67,8 @@
   // Build the AST expression & statement for assigning pointsize one.
   auto* one = mod->create<ast::ScalarConstructorExpression>(
       mod->create<ast::FloatLiteral>(f32, 1.0f));
-  auto* pointsize_ident =
-      mod->create<ast::IdentifierExpression>(Source{}, kPointSizeVar);
+  auto* pointsize_ident = mod->create<ast::IdentifierExpression>(
+      Source{}, mod->RegisterSymbol(kPointSizeVar), kPointSizeVar);
   auto* pointsize_assign =
       mod->create<ast::AssignmentStatement>(pointsize_ident, one);
 

diff --git a/src/transform/emit_vertex_point_size_test.cc b/src/transform/emit_vertex_point_size_test.cc
index 57a9047..f0d6ba8 100644
--- a/src/transform/emit_vertex_point_size_test.cc
+++ b/src/transform/emit_vertex_point_size_test.cc

@@ -21,6 +21,7 @@
 #include "src/ast/builder.h"
 #include "src/ast/stage_decoration.h"
 #include "src/ast/variable_decl_statement.h"
+#include "src/demangler.h"
 #include "src/diagnostic/formatter.h"
 #include "src/transform/manager.h"
 
@@ -85,7 +86,7 @@
   ASSERT_FALSE(result.diagnostics.contains_errors())
       << diag::Formatter().format(result.diagnostics);
 
-  auto expected = R"(Module{
+  auto* expected = R"(Module{
   Variable{
     Decorations{
       BuiltinDecoration{pointsize}
@@ -94,13 +95,11 @@
     out
     __f32
   }
-  Function )" + result.module.RegisterSymbol("non_entry_a").to_str() +
-                  R"( -> __void
+  Function non_entry_a -> __void
   ()
   {
   }
-  Function )" + result.module.RegisterSymbol("entry").to_str() +
-                  R"( -> __void
+  Function entry -> __void
   StageDecoration{vertex}
   ()
   {
@@ -116,14 +115,14 @@
       }
     }
   }
-  Function )" + result.module.RegisterSymbol("non_entry_b").to_str() +
-                  R"( -> __void
+  Function non_entry_b -> __void
   ()
   {
   }
 }
 )";
-  EXPECT_EQ(expected, result.module.to_str());
+  EXPECT_EQ(expected,
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
@@ -156,7 +155,7 @@
   ASSERT_FALSE(result.diagnostics.contains_errors())
       << diag::Formatter().format(result.diagnostics);
 
-  auto expected = R"(Module{
+  auto* expected = R"(Module{
   Variable{
     Decorations{
       BuiltinDecoration{pointsize}
@@ -165,13 +164,11 @@
     out
     __f32
   }
-  Function )" + result.module.RegisterSymbol("non_entry_a").to_str() +
-                  R"( -> __void
+  Function non_entry_a -> __void
   ()
   {
   }
-  Function )" + result.module.RegisterSymbol("entry").to_str() +
-                  R"( -> __void
+  Function entry -> __void
   StageDecoration{vertex}
   ()
   {
@@ -180,14 +177,14 @@
       ScalarConstructor[__f32]{1.000000}
     }
   }
-  Function )" + result.module.RegisterSymbol("non_entry_b").to_str() +
-                  R"( -> __void
+  Function non_entry_b -> __void
   ()
   {
   }
 }
 )";
-  EXPECT_EQ(expected, result.module.to_str());
+  EXPECT_EQ(expected,
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(EmitVertexPointSizeTest, NonVertexStage) {
@@ -219,22 +216,21 @@
   ASSERT_FALSE(result.diagnostics.contains_errors())
       << diag::Formatter().format(result.diagnostics);
 
-  auto expected = R"(Module{
-  Function )" + result.module.RegisterSymbol("fragment_entry").to_str() +
-                  R"( -> __void
+  auto* expected = R"(Module{
+  Function fragment_entry -> __void
   StageDecoration{fragment}
   ()
   {
   }
-  Function )" + result.module.RegisterSymbol("compute_entry").to_str() +
-                  R"( -> __void
+  Function compute_entry -> __void
   StageDecoration{compute}
   ()
   {
   }
 }
 )";
-  EXPECT_EQ(expected, result.module.to_str());
+  EXPECT_EQ(expected,
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 }  // namespace

diff --git a/src/transform/first_index_offset.cc b/src/transform/first_index_offset.cc
index b398935..ee75a77 100644
--- a/src/transform/first_index_offset.cc
+++ b/src/transform/first_index_offset.cc

@@ -251,13 +251,16 @@
     const std::string& field_name,
     ast::Variable* buffer_var,
     ast::Module* mod) {
-  auto* buffer = mod->create<ast::IdentifierExpression>(buffer_var->name());
+  auto* buffer = mod->create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(buffer_var->name()), buffer_var->name());
   auto* constructor = mod->create<ast::BinaryExpression>(
       ast::BinaryOp::kAdd,
-      mod->create<ast::IdentifierExpression>(kIndexOffsetPrefix +
-                                             original_name),
+      mod->create<ast::IdentifierExpression>(
+          mod->RegisterSymbol(kIndexOffsetPrefix + original_name),
+          kIndexOffsetPrefix + original_name),
       mod->create<ast::MemberAccessorExpression>(
-          buffer, mod->create<ast::IdentifierExpression>(field_name)));
+          buffer, mod->create<ast::IdentifierExpression>(
+                      mod->RegisterSymbol(field_name), field_name)));
   auto* var =
       mod->create<ast::Variable>(Source{},                  // source
                                  original_name,             // name

diff --git a/src/transform/first_index_offset_test.cc b/src/transform/first_index_offset_test.cc
index 20fbb75..3813819 100644
--- a/src/transform/first_index_offset_test.cc
+++ b/src/transform/first_index_offset_test.cc

@@ -74,7 +74,8 @@
     void Build() override {
       AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
       AddFunction("test")->body()->append(create<ast::ReturnStatement>(
-          Source{}, create<ast::IdentifierExpression>("vert_idx")));
+          Source{}, create<ast::IdentifierExpression>(
+                        mod->RegisterSymbol("vert_idx"), "vert_idx")));
     }
   };
 
@@ -115,7 +116,8 @@
     void Build() override {
       AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
       AddFunction("test")->body()->append(create<ast::ReturnStatement>(
-          Source{}, create<ast::IdentifierExpression>("vert_idx")));
+          Source{}, create<ast::IdentifierExpression>(
+                        mod->RegisterSymbol("vert_idx"), "vert_idx")));
     }
   };
 
@@ -191,7 +193,8 @@
     void Build() override {
       AddBuiltinInput("inst_idx", ast::Builtin::kInstanceIdx);
       AddFunction("test")->body()->append(create<ast::ReturnStatement>(
-          Source{}, create<ast::IdentifierExpression>("inst_idx")));
+          Source{}, create<ast::IdentifierExpression>(
+                        mod->RegisterSymbol("inst_idx"), "inst_idx")));
     }
   };
 
@@ -344,11 +347,13 @@
       AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
       ast::Function* func1 = AddFunction("func1");
       func1->body()->append(create<ast::ReturnStatement>(
-          Source{}, create<ast::IdentifierExpression>("vert_idx")));
+          Source{}, create<ast::IdentifierExpression>(
+                        mod->RegisterSymbol("vert_idx"), "vert_idx")));
       ast::Function* func2 = AddFunction("func2");
       func2->body()->append(create<ast::ReturnStatement>(
           Source{}, create<ast::CallExpression>(
-                        create<ast::IdentifierExpression>("func1"),
+                        create<ast::IdentifierExpression>(
+                            mod->RegisterSymbol("func1"), "func1"),
                         ast::ExpressionList{})));
     }
   };

diff --git a/src/transform/vertex_pulling.cc b/src/transform/vertex_pulling.cc
index 6143d15..05fbae5 100644
--- a/src/transform/vertex_pulling.cc
+++ b/src/transform/vertex_pulling.cc

@@ -321,11 +321,12 @@
       }
       auto* v = it->second;
 
+      auto name = buffer_layout.step_mode == InputStepMode::kVertex
+                      ? vertex_index_name
+                      : instance_index_name;
       // Identifier to index by
       auto* index_identifier = mod->create<ast::IdentifierExpression>(
-          buffer_layout.step_mode == InputStepMode::kVertex
-              ? vertex_index_name
-              : instance_index_name);
+          mod->RegisterSymbol(name), name);
 
       // An expression for the start of the read in the buffer in bytes
       auto* pos_value = mod->create<ast::BinaryExpression>(
@@ -341,7 +342,8 @@
       block->append(set_pos_expr);
 
       block->append(mod->create<ast::AssignmentStatement>(
-          mod->create<ast::IdentifierExpression>(v->name()),
+          mod->create<ast::IdentifierExpression>(mod->RegisterSymbol(v->name()),
+                                                 v->name()),
           AccessByFormat(i, attribute_desc.format)));
     }
   }
@@ -355,7 +357,8 @@
 }
 
 ast::Expression* VertexPulling::State::CreatePullingPositionIdent() {
-  return mod->create<ast::IdentifierExpression>(kPullingPosVarName);
+  return mod->create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(kPullingPosVarName), kPullingPosVarName);
 }
 
 ast::Expression* VertexPulling::State::AccessByFormat(uint32_t buffer,
@@ -392,10 +395,13 @@
   // by dividing. Then, that element is going to be read, and if needed,
   // unpacked into an appropriate variable. All reads should end up here as a
   // base case.
+  auto vbuf_name = GetVertexBufferName(buffer);
   return mod->create<ast::ArrayAccessorExpression>(
       mod->create<ast::MemberAccessorExpression>(
-          mod->create<ast::IdentifierExpression>(GetVertexBufferName(buffer)),
-          mod->create<ast::IdentifierExpression>(kStructBufferName)),
+          mod->create<ast::IdentifierExpression>(mod->RegisterSymbol(vbuf_name),
+                                                 vbuf_name),
+          mod->create<ast::IdentifierExpression>(
+              mod->RegisterSymbol(kStructBufferName), kStructBufferName)),
       mod->create<ast::BinaryExpression>(ast::BinaryOp::kDivide, pos,
                                          GenUint(4)));
 }

diff --git a/src/transform/vertex_pulling_test.cc b/src/transform/vertex_pulling_test.cc
index c027920..8d950d5 100644
--- a/src/transform/vertex_pulling_test.cc
+++ b/src/transform/vertex_pulling_test.cc

@@ -24,7 +24,7 @@
 #include "src/ast/type/f32_type.h"
 #include "src/ast/type/i32_type.h"
 #include "src/ast/type/void_type.h"
-#include "src/ast/variable.h"
+#include "src/demangler.h"
 #include "src/diagnostic/formatter.h"
 #include "src/transform/manager.h"
 #include "src/type_determiner.h"
@@ -195,8 +195,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -240,7 +239,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(VertexPullingTest, OneInstancedAttribute) {
@@ -283,8 +282,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -328,7 +326,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
@@ -371,8 +369,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -416,7 +413,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 // We expect the transform to use an existing builtin variables if it finds them
@@ -510,8 +507,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -583,7 +579,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
@@ -636,8 +632,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -767,7 +762,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 TEST_F(VertexPullingTest, FloatVectorAttributes) {
@@ -847,8 +842,7 @@
     storage_buffer
     __struct_TintVertexData
   }
-  Function )" + result.module.GetSymbol("main").to_str() +
-                R"( -> __void
+  Function main -> __void
   StageDecoration{vertex}
   ()
   {
@@ -1071,7 +1065,7 @@
   }
 }
 )",
-            result.module.to_str());
+            Demangler().Demangle(result.module, result.module.to_str()));
 }
 
 }  // namespace

diff --git a/src/type_determiner_test.cc b/src/type_determiner_test.cc
index a45e896..1422aab 100644
--- a/src/type_determiner_test.cc
+++ b/src/type_determiner_test.cc

@@ -351,7 +351,9 @@
 
   ast::ExpressionList call_params;
   auto* expr = create<ast::CallExpression>(
-      create<ast::IdentifierExpression>("my_func"), call_params);
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_func"),
+                                        "my_func"),
+      call_params);
 
   ast::CallStatement call(expr);
   EXPECT_TRUE(td()->DetermineResultType(&call));
@@ -364,10 +366,10 @@
   // fn func() -> void { return; }
   ast::type::F32 f32;
   ast::ExpressionList call_params;
-  auto* call_expr =
-      create<ast::CallExpression>(create<ast::IdentifierExpression>(
-                                      Source{Source::Location{12, 34}}, "func"),
-                                  call_params);
+  auto* call_expr = create<ast::CallExpression>(
+      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}},
+                                        mod->RegisterSymbol("func"), "func"),
+      call_params);
   ast::VariableList params0;
   auto* main_body = create<ast::BlockStatement>();
   main_body->append(create<ast::CallStatement>(call_expr));
@@ -457,7 +459,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>("my_var"),
+  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>(
+                                       mod->RegisterSymbol("my_var"), "my_var"),
                                    idx);
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
@@ -488,7 +491,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>("my_var"),
+  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>(
+                                       mod->RegisterSymbol("my_var"), "my_var"),
                                    idx);
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
@@ -518,7 +522,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>("my_var"),
+  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>(
+                                       mod->RegisterSymbol("my_var"), "my_var"),
                                    idx);
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
@@ -546,7 +551,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>("my_var"),
+  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>(
+                                       mod->RegisterSymbol("my_var"), "my_var"),
                                    idx);
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
@@ -581,7 +587,9 @@
 
   ast::ArrayAccessorExpression acc(
       create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("my_var"), idx1),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("my_var"),
+                                            "my_var"),
+          idx1),
       idx2);
 
   EXPECT_TRUE(td()->DetermineResultType(&acc));
@@ -612,7 +620,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>("my_var"),
+  ast::ArrayAccessorExpression acc(create<ast::IdentifierExpression>(
+                                       mod->RegisterSymbol("my_var"), "my_var"),
                                    idx);
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
@@ -624,8 +633,9 @@
 
 TEST_F(TypeDeterminerTest, Expr_Bitcast) {
   ast::type::F32 f32;
-  ast::BitcastExpression bitcast(&f32,
-                                 create<ast::IdentifierExpression>("name"));
+  ast::BitcastExpression bitcast(
+      &f32,
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("name"), "name"));
 
   ast::Variable v(Source{}, "name", ast::StorageClass::kPrivate, &f32, false,
                   nullptr, ast::VariableDecorationList{});
@@ -649,7 +659,8 @@
   EXPECT_TRUE(td()->Determine());
 
   ast::ExpressionList call_params;
-  ast::CallExpression call(create<ast::IdentifierExpression>("my_func"),
+  ast::CallExpression call(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("my_func"), "my_func"),
                            call_params);
   EXPECT_TRUE(td()->DetermineResultType(&call));
   ASSERT_NE(call.result_type(), nullptr);
@@ -674,7 +685,8 @@
 
   auto* param = call_params.back();
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("my_func"),
+  ast::CallExpression call(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("my_func"), "my_func"),
                            call_params);
   EXPECT_TRUE(td()->DetermineResultType(&call));
   ASSERT_NE(param->result_type(), nullptr);
@@ -691,8 +703,9 @@
   call_params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.4)));
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("round"),
-                           call_params);
+  ast::CallExpression call(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("round"), "round"),
+      call_params);
 
   EXPECT_TRUE(td()->DetermineResultType(&call));
   ASSERT_NE(call.result_type(), nullptr);
@@ -703,7 +716,8 @@
   ast::type::F32 f32;
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("name"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("name"), "name"));
   ast::TypeConstructorExpression cast(&f32, params);
 
   ast::Variable v(Source{}, "name", ast::StorageClass::kPrivate, &f32, false,
@@ -761,7 +775,7 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::IdentifierExpression ident("my_var");
+  ast::IdentifierExpression ident(mod->RegisterSymbol("my_var"), "my_var");
   EXPECT_TRUE(td()->DetermineResultType(&ident));
   ASSERT_NE(ident.result_type(), nullptr);
   EXPECT_TRUE(ident.result_type()->Is<ast::type::Pointer>());
@@ -785,7 +799,7 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::IdentifierExpression ident("my_var");
+  ast::IdentifierExpression ident(mod->RegisterSymbol("my_var"), "my_var");
   EXPECT_TRUE(td()->DetermineResultType(&ident));
   ASSERT_NE(ident.result_type(), nullptr);
   EXPECT_TRUE(ident.result_type()->Is<ast::type::F32>());
@@ -794,7 +808,8 @@
 TEST_F(TypeDeterminerTest, Expr_Identifier_FunctionVariable_Const) {
   ast::type::F32 f32;
 
-  auto* my_var = create<ast::IdentifierExpression>("my_var");
+  auto* my_var = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var");
 
   auto* var =
       create<ast::Variable>(Source{},                        // source
@@ -808,7 +823,8 @@
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
   body->append(create<ast::AssignmentStatement>(
-      my_var, create<ast::IdentifierExpression>("my_var")));
+      my_var, create<ast::IdentifierExpression>(mod->RegisterSymbol("my_var"),
+                                                "my_var")));
 
   ast::Function f(Source{}, mod->RegisterSymbol("my_func"), "my_func", {}, &f32,
                   body, ast::FunctionDecorationList{});
@@ -822,7 +838,8 @@
 TEST_F(TypeDeterminerTest, Expr_Identifier_FunctionVariable) {
   ast::type::F32 f32;
 
-  auto* my_var = create<ast::IdentifierExpression>("my_var");
+  auto* my_var = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var");
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(
@@ -835,7 +852,8 @@
                             ast::VariableDecorationList{})));  // decorations
 
   body->append(create<ast::AssignmentStatement>(
-      my_var, create<ast::IdentifierExpression>("my_var")));
+      my_var, create<ast::IdentifierExpression>(mod->RegisterSymbol("my_var"),
+                                                "my_var")));
 
   ast::Function f(Source{}, mod->RegisterSymbol("myfunc"), "my_func", {}, &f32,
                   body, ast::FunctionDecorationList{});
@@ -854,7 +872,8 @@
   ast::type::F32 f32;
   ast::type::Pointer ptr(&f32, ast::StorageClass::kFunction);
 
-  auto* my_var = create<ast::IdentifierExpression>("my_var");
+  auto* my_var = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var");
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(
@@ -867,7 +886,8 @@
                             ast::VariableDecorationList{})));  // decorations
 
   body->append(create<ast::AssignmentStatement>(
-      my_var, create<ast::IdentifierExpression>("my_var")));
+      my_var, create<ast::IdentifierExpression>(mod->RegisterSymbol("my_var"),
+                                                "my_var")));
 
   ast::Function f(Source{}, mod->RegisterSymbol("my_func"), "my_func", {}, &f32,
                   body, ast::FunctionDecorationList{});
@@ -894,14 +914,14 @@
   // Register the function
   EXPECT_TRUE(td()->Determine());
 
-  ast::IdentifierExpression ident("my_func");
+  ast::IdentifierExpression ident(mod->RegisterSymbol("my_func"), "my_func");
   EXPECT_TRUE(td()->DetermineResultType(&ident));
   ASSERT_NE(ident.result_type(), nullptr);
   EXPECT_TRUE(ident.result_type()->Is<ast::type::F32>());
 }
 
 TEST_F(TypeDeterminerTest, Expr_Identifier_Unknown) {
-  ast::IdentifierExpression a("a");
+  ast::IdentifierExpression a(mod->RegisterSymbol("a"), "a");
   EXPECT_FALSE(td()->DetermineResultType(&a));
 }
 
@@ -958,17 +978,25 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("out_var"),
-      create<ast::IdentifierExpression>("in_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("out_var"),
+                                        "out_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("in_var"),
+                                        "in_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("wg_var"),
-      create<ast::IdentifierExpression>("wg_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("wg_var"),
+                                        "wg_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("wg_var"),
+                                        "wg_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("sb_var"),
-      create<ast::IdentifierExpression>("sb_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("sb_var"),
+                                        "sb_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("sb_var"),
+                                        "sb_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("priv_var"),
-      create<ast::IdentifierExpression>("priv_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("priv_var"),
+                                        "priv_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("priv_var"),
+                                        "priv_var")));
   auto* func =
       create<ast::Function>(Source{}, mod->RegisterSymbol("my_func"), "my_func",
                             params, &f32, body, ast::FunctionDecorationList{});
@@ -1039,17 +1067,25 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("out_var"),
-      create<ast::IdentifierExpression>("in_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("out_var"),
+                                        "out_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("in_var"),
+                                        "in_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("wg_var"),
-      create<ast::IdentifierExpression>("wg_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("wg_var"),
+                                        "wg_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("wg_var"),
+                                        "wg_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("sb_var"),
-      create<ast::IdentifierExpression>("sb_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("sb_var"),
+                                        "sb_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("sb_var"),
+                                        "sb_var")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("priv_var"),
-      create<ast::IdentifierExpression>("priv_var")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("priv_var"),
+                                        "priv_var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("priv_var"),
+                                        "priv_var")));
   ast::VariableList params;
   auto* func =
       create<ast::Function>(Source{}, mod->RegisterSymbol("my_func"), "my_func",
@@ -1059,9 +1095,12 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("out_var"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("my_func"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("out_var"),
+                                        "out_var"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("my_func"),
+                                            "my_func"),
+          ast::ExpressionList{})));
   auto* func2 =
       create<ast::Function>(Source{}, mod->RegisterSymbol("func"), "func",
                             params, &f32, body, ast::FunctionDecorationList{});
@@ -1095,7 +1134,7 @@
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 1.f))));
 
@@ -1143,8 +1182,10 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  auto* ident = create<ast::IdentifierExpression>("my_struct");
-  auto* mem_ident = create<ast::IdentifierExpression>("second_member");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_struct"), "my_struct");
+  auto* mem_ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("second_member"), "second_member");
 
   ast::MemberAccessorExpression mem(ident, mem_ident);
   EXPECT_TRUE(td()->DetermineResultType(&mem));
@@ -1183,8 +1224,10 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  auto* ident = create<ast::IdentifierExpression>("my_struct");
-  auto* mem_ident = create<ast::IdentifierExpression>("second_member");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_struct"), "my_struct");
+  auto* mem_ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("second_member"), "second_member");
 
   ast::MemberAccessorExpression mem(ident, mem_ident);
   EXPECT_TRUE(td()->DetermineResultType(&mem));
@@ -1212,8 +1255,10 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  auto* ident = create<ast::IdentifierExpression>("my_vec");
-  auto* swizzle = create<ast::IdentifierExpression>("xy");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("my_vec"),
+                                                  "my_vec");
+  auto* swizzle =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("xy"), "xy");
 
   ast::MemberAccessorExpression mem(ident, swizzle);
   EXPECT_TRUE(td()->DetermineResultType(&mem)) << td()->error();
@@ -1241,8 +1286,10 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  auto* ident = create<ast::IdentifierExpression>("my_vec");
-  auto* swizzle = create<ast::IdentifierExpression>("x");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("my_vec"),
+                                                  "my_vec");
+  auto* swizzle =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("x"), "x");
 
   ast::MemberAccessorExpression mem(ident, swizzle);
   EXPECT_TRUE(td()->DetermineResultType(&mem)) << td()->error();
@@ -1312,12 +1359,16 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  auto* ident = create<ast::IdentifierExpression>("c");
-  auto* mem_ident = create<ast::IdentifierExpression>("mem");
-  auto* foo_ident = create<ast::IdentifierExpression>("foo");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("c"), "c");
+  auto* mem_ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mem"), "mem");
+  auto* foo_ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("foo"), "foo");
   auto* idx = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 0));
-  auto* swizzle = create<ast::IdentifierExpression>("yx");
+  auto* swizzle =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("yx"), "yx");
 
   ast::MemberAccessorExpression mem(
       create<ast::MemberAccessorExpression>(
@@ -1353,8 +1404,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1380,8 +1432,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1423,8 +1476,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1450,8 +1504,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1486,8 +1541,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1513,8 +1569,9 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(op, create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      op, create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1550,9 +1607,10 @@
   // Register the global
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
-  ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("val"),
-                             create<ast::IdentifierExpression>("val"));
+  ast::BinaryExpression expr(
+      ast::BinaryOp::kMultiply,
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("val"), "val"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1586,8 +1644,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("vector"),
-                             create<ast::IdentifierExpression>("scalar"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("scalar"), "scalar"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1626,8 +1686,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("scalar"),
-                             create<ast::IdentifierExpression>("vector"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("scalar"), "scalar"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1657,8 +1719,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("vector"),
-                             create<ast::IdentifierExpression>("vector"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1697,8 +1761,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("matrix"),
-                             create<ast::IdentifierExpression>("scalar"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("matrix"), "matrix"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("scalar"), "scalar"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1737,8 +1803,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("scalar"),
-                             create<ast::IdentifierExpression>("matrix"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("scalar"), "scalar"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("matrix"), "matrix"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1778,8 +1846,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("matrix"),
-                             create<ast::IdentifierExpression>("vector"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("matrix"), "matrix"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1819,8 +1889,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("vector"),
-                             create<ast::IdentifierExpression>("matrix"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("vector"), "vector"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("matrix"), "matrix"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1860,8 +1932,10 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::BinaryExpression expr(ast::BinaryOp::kMultiply,
-                             create<ast::IdentifierExpression>("mat4x3"),
-                             create<ast::IdentifierExpression>("mat3x4"));
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("mat4x3"), "mat4x3"),
+                             create<ast::IdentifierExpression>(
+                                 mod->RegisterSymbol("mat3x4"), "mat3x4"));
 
   ASSERT_TRUE(td()->DetermineResultType(&expr)) << td()->error();
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1893,10 +1967,12 @@
   EXPECT_TRUE(td()->Determine());
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("ident"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
   EXPECT_TRUE(td()->DetermineResultType(&expr));
 
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1923,10 +1999,12 @@
   EXPECT_TRUE(td()->Determine());
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("ident"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
   EXPECT_TRUE(td()->DetermineResultType(&expr));
 
   ASSERT_NE(expr.result_type(), nullptr);
@@ -1948,8 +2026,9 @@
   EXPECT_TRUE(td()->Determine());
 
   ast::ExpressionList call_params;
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
   EXPECT_FALSE(td()->DetermineResultType(&expr));
   EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
 }
@@ -1983,11 +2062,14 @@
   EXPECT_TRUE(td()->Determine());
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("ident1"));
-  call_params.push_back(create<ast::IdentifierExpression>("ident2"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("ident1"), "ident1"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("ident2"), "ident2"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
   EXPECT_FALSE(td()->DetermineResultType(&expr));
   EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
 }
@@ -2021,10 +2103,12 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2055,10 +2139,12 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2089,10 +2175,12 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2117,8 +2205,9 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2142,11 +2231,14 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(name),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2216,7 +2308,8 @@
                               nullptr,                         // constructor
                               ast::VariableDecorationList{});  // decorations
     mod->AddGlobalVariable(var);
-    call_params->push_back(create<ast::IdentifierExpression>(name));
+    call_params->push_back(
+        create<ast::IdentifierExpression>(mod->RegisterSymbol(name), name));
   }
 
   std::unique_ptr<ast::type::Type> subtype(Texture type) {
@@ -2248,8 +2341,10 @@
   add_call_param("coords", coords_type.get(), &call_params);
   add_call_param("lod", &i32, &call_params);
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("textureLoad"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("textureLoad"),
+                                        "textureLoad"),
+      call_params);
 
   EXPECT_TRUE(td()->Determine());
   EXPECT_TRUE(td()->DetermineResultType(&expr));
@@ -2326,8 +2421,10 @@
   add_call_param("coords", coords_type.get(), &call_params);
   add_call_param("lod", &i32, &call_params);
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("textureLoad"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("textureLoad"),
+                                        "textureLoad"),
+      call_params);
 
   EXPECT_TRUE(td()->Determine());
   EXPECT_TRUE(td()->DetermineResultType(&expr));
@@ -2377,11 +2474,14 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("dot"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("dot"), "dot"),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2416,11 +2516,15 @@
   mod->AddGlobalVariable(bool_var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
-  call_params.push_back(create<ast::IdentifierExpression>("my_var"));
-  call_params.push_back(create<ast::IdentifierExpression>("bool_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("my_var"), "my_var"));
+  call_params.push_back(create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("bool_var"), "bool_var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("select"),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("select"), "select"),
                            call_params);
 
   // Register the variable
@@ -2450,9 +2554,11 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("v"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("select"),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("select"), "select"),
                            call_params);
 
   // Register the variable
@@ -2477,12 +2583,17 @@
   mod->AddGlobalVariable(var);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("v"));
-  call_params.push_back(create<ast::IdentifierExpression>("v"));
-  call_params.push_back(create<ast::IdentifierExpression>("v"));
-  call_params.push_back(create<ast::IdentifierExpression>("v"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("select"),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("select"), "select"),
                            call_params);
 
   // Register the variable
@@ -2517,11 +2628,15 @@
   mod->AddGlobalVariable(var2);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("v3"));
-  call_params.push_back(create<ast::IdentifierExpression>("v2"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v3"), "v3"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v2"), "v2"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("outerProduct"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("outerProduct"),
+                                        "outerProduct"),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2552,10 +2667,13 @@
   mod->AddGlobalVariable(var2);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("v2"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v2"), "v2"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("outerProduct"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("outerProduct"),
+                                        "outerProduct"),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2579,12 +2697,17 @@
   mod->AddGlobalVariable(var2);
 
   ast::ExpressionList call_params;
-  call_params.push_back(create<ast::IdentifierExpression>("v2"));
-  call_params.push_back(create<ast::IdentifierExpression>("v2"));
-  call_params.push_back(create<ast::IdentifierExpression>("v2"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v2"), "v2"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v2"), "v2"));
+  call_params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v2"), "v2"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("outerProduct"),
-                           call_params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("outerProduct"),
+                                        "outerProduct"),
+      call_params);
 
   // Register the variable
   EXPECT_TRUE(td()->Determine());
@@ -2613,7 +2736,8 @@
   // Register the global
   EXPECT_TRUE(td()->Determine());
 
-  ast::UnaryOpExpression der(op, create<ast::IdentifierExpression>("ident"));
+  ast::UnaryOpExpression der(op, create<ast::IdentifierExpression>(
+                                     mod->RegisterSymbol("ident"), "ident"));
   EXPECT_TRUE(td()->DetermineResultType(&der));
   ASSERT_NE(der.result_type(), nullptr);
   ASSERT_TRUE(der.result_type()->Is<ast::type::Vector>());
@@ -2714,7 +2838,7 @@
 TEST_P(IntrinsicDataTest, Lookup) {
   auto param = GetParam();
 
-  ast::IdentifierExpression ident(param.name);
+  ast::IdentifierExpression ident(mod->RegisterSymbol(param.name), param.name);
   EXPECT_TRUE(td()->SetIntrinsicIfNeeded(&ident));
   EXPECT_EQ(ident.intrinsic(), param.intrinsic);
   EXPECT_TRUE(ident.IsIntrinsic());
@@ -2795,7 +2919,8 @@
         IntrinsicData{"trunc", ast::Intrinsic::kTrunc}));
 
 TEST_F(TypeDeterminerTest, IntrinsicNotSetIfNotMatched) {
-  ast::IdentifierExpression ident("not_intrinsic");
+  ast::IdentifierExpression ident(mod->RegisterSymbol("not_intrinsic"),
+                                  "not_intrinsic");
   EXPECT_FALSE(td()->SetIntrinsicIfNeeded(&ident));
   EXPECT_EQ(ident.intrinsic(), ast::Intrinsic::kNone);
   EXPECT_FALSE(ident.IsIntrinsic());
@@ -2811,7 +2936,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -2837,7 +2963,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -2856,7 +2983,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -2870,7 +2998,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -2890,7 +3019,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -2935,7 +3065,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -2961,7 +3092,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -2980,7 +3112,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, -11)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3006,7 +3139,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3025,7 +3159,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::UintLiteral>(&u32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3051,7 +3186,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3070,7 +3206,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, false)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3084,7 +3221,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3104,7 +3242,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3126,7 +3265,8 @@
 
   ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
 
-  auto* ident = create<ast::IdentifierExpression>("length");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("length"),
+                                                  "length");
 
   ast::CallExpression call(ident, params);
 
@@ -3150,7 +3290,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>("length");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("length"),
+                                                  "length");
 
   ast::CallExpression call(ident, params);
 
@@ -3166,7 +3307,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>("length");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("length"),
+                                                  "length");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3178,7 +3320,8 @@
 TEST_F(TypeDeterminerTest, ImportData_Length_Error_NoParams) {
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>("length");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("length"),
+                                                  "length");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3196,7 +3339,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>("length");
+  auto* ident = create<ast::IdentifierExpression>(mod->RegisterSymbol("length"),
+                                                  "length");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3216,7 +3360,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3251,7 +3396,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3272,7 +3418,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3286,7 +3433,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3302,7 +3450,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3335,7 +3484,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec2, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3362,7 +3512,8 @@
       create<ast::FloatLiteral>(&f32, 1.0f)));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3382,7 +3533,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3407,7 +3559,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
 
   ast::CallExpression call(ident, params);
 
@@ -3440,7 +3593,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
 
   ast::CallExpression call(ident, params);
 
@@ -3458,7 +3612,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2)));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3470,7 +3625,8 @@
 TEST_F(TypeDeterminerTest, ImportData_Distance_Error_NoParams) {
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3484,7 +3640,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3515,7 +3672,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec2, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3539,7 +3697,8 @@
       create<ast::FloatLiteral>(&f32, 1.0f)));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3556,7 +3715,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>("distance");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("distance"), "distance");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3588,7 +3748,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
 
   ast::CallExpression call(ident, params);
 
@@ -3607,7 +3768,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3639,7 +3801,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3649,7 +3812,8 @@
 
 TEST_F(TypeDeterminerTest, ImportData_Cross_Error_MissingParams) {
   ast::ExpressionList params;
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3672,7 +3836,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
 
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3713,7 +3878,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>("cross");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("cross"), "cross");
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3735,7 +3901,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3779,7 +3946,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -3802,7 +3970,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 3)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3816,7 +3985,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3832,7 +4002,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3850,7 +4021,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3892,7 +4064,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3921,7 +4094,8 @@
       create<ast::FloatLiteral>(&f32, 1.0f)));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3943,7 +4117,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -3975,7 +4150,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4019,7 +4195,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4042,7 +4219,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4086,7 +4264,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4109,7 +4288,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::UintLiteral>(&u32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4153,7 +4333,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4176,7 +4357,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, true)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4190,7 +4372,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4206,7 +4389,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4224,7 +4408,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4266,7 +4451,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_2));
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_3));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4295,7 +4481,8 @@
       create<ast::FloatLiteral>(&f32, 1.0f)));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4317,7 +4504,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4341,7 +4529,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4367,7 +4556,8 @@
   ast::ExpressionList params;
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4386,7 +4576,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4400,7 +4591,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4420,7 +4612,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4448,7 +4641,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4468,7 +4662,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::UintLiteral>(&u32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4488,7 +4683,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4523,7 +4719,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4559,7 +4756,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4595,7 +4793,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -4616,7 +4815,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, false)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4630,7 +4830,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4646,7 +4847,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4679,7 +4881,8 @@
   params.push_back(create<ast::TypeConstructorExpression>(&vec2, vals_1));
   params.push_back(create<ast::TypeConstructorExpression>(&vec3, vals_2));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4706,7 +4909,8 @@
       create<ast::SintLiteral>(&i32, 1)));
   params.push_back(create<ast::TypeConstructorExpression>(&vec, vals));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4726,7 +4930,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4758,9 +4963,11 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"));
 
-  auto* ident = create<ast::IdentifierExpression>("determinant");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol("determinant"), "determinant");
 
   ast::CallExpression call(ident, params);
 
@@ -4790,9 +4997,11 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4805,7 +5014,8 @@
 
   ast::ExpressionList params;
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4833,10 +5043,13 @@
   ASSERT_TRUE(td()->Determine()) << td()->error();
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("var"));
-  params.push_back(create<ast::IdentifierExpression>("var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod->RegisterSymbol(param.name), param.name);
   ast::CallExpression call(ident, params);
 
   EXPECT_FALSE(td()->DetermineResultType(&call));
@@ -4871,31 +5084,38 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("second"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("b"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("second"),
+                                        "second"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"),
+          ast::ExpressionList{})));
   auto* func_c =
       create<ast::Function>(Source{}, mod->RegisterSymbol("c"), "c", params,
                             &f32, body, ast::FunctionDecorationList{});
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("first"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("c"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("first"), "first"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("c"), "c"),
+          ast::ExpressionList{})));
   auto* func_a =
       create<ast::Function>(Source{}, mod->RegisterSymbol("a"), "a", params,
                             &f32, body, ast::FunctionDecorationList{});
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("call_a"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("a"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("call_a"),
+                                        "call_a"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
+          ast::ExpressionList{})));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("call_b"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("b"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("call_b"),
+                                        "call_b"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"),
+          ast::ExpressionList{})));
   auto* ep_1 = create<ast::Function>(
       Source{}, mod->RegisterSymbol("ep_1"), "ep_1", params, &f32, body,
       ast::FunctionDecorationList{
@@ -4904,9 +5124,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("call_c"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("c"),
-                                  ast::ExpressionList{})));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("call_c"),
+                                        "call_c"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("c"), "c"),
+          ast::ExpressionList{})));
   auto* ep_2 = create<ast::Function>(
       Source{}, mod->RegisterSymbol("ep_2"), "ep_2", params, &f32, body,
       ast::FunctionDecorationList{

diff --git a/src/validator/validator_control_block_test.cc b/src/validator/validator_control_block_test.cc
index b4c5990..cffdf1e 100644
--- a/src/validator/validator_control_block_test.cc
+++ b/src/validator/validator_control_block_test.cc

@@ -53,8 +53,8 @@
           create<ast::SintLiteral>(&f32, 3.14f)),  // constructor
       ast::VariableDecorationList{});              // decorations
 
-  auto* cond =
-      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
+  auto* cond = create<ast::IdentifierExpression>(
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
   ast::CaseSelectorList default_csl;
   auto* block_default = create<ast::BlockStatement>();
   ast::CaseStatementList body;
@@ -87,7 +87,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   ast::CaseSelectorList csl;
   csl.push_back(create<ast::SintLiteral>(&i32, 1));
   ast::CaseStatementList body;
@@ -125,7 +126,8 @@
       ast::VariableDecorationList{});          // decorations
 
   ast::CaseStatementList switch_body;
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
 
   ast::CaseSelectorList default_csl_1;
   auto* block_default_1 = create<ast::BlockStatement>();
@@ -174,7 +176,8 @@
       ast::VariableDecorationList{});          // decorations
 
   ast::CaseStatementList switch_body;
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
 
   ast::CaseSelectorList csl;
   csl.push_back(create<ast::UintLiteral>(&u32, 1));
@@ -216,7 +219,8 @@
       ast::VariableDecorationList{});          // decorations
 
   ast::CaseStatementList switch_body;
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
 
   ast::CaseSelectorList csl;
   csl.push_back(create<ast::SintLiteral>(&i32, -1));
@@ -257,7 +261,8 @@
       ast::VariableDecorationList{});          // decorations
 
   ast::CaseStatementList switch_body;
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
 
   ast::CaseSelectorList csl_1;
   csl_1.push_back(create<ast::UintLiteral>(&u32, 0));
@@ -304,7 +309,8 @@
       ast::VariableDecorationList{});          // decorations
 
   ast::CaseStatementList switch_body;
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
 
   ast::CaseSelectorList csl_1;
   csl_1.push_back(create<ast::SintLiteral>(&i32, 10));
@@ -350,7 +356,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   ast::CaseSelectorList default_csl;
   auto* block_default = create<ast::BlockStatement>();
   block_default->append(
@@ -386,7 +393,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   ast::CaseSelectorList default_csl;
   auto* block_default = create<ast::BlockStatement>();
   ast::CaseStatementList body;
@@ -425,7 +433,8 @@
           create<ast::SintLiteral>(&u32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* cond = create<ast::IdentifierExpression>("a");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   ast::CaseSelectorList default_csl;
   auto* block_default = create<ast::BlockStatement>();
   ast::CaseStatementList body;

diff --git a/src/validator/validator_function_test.cc b/src/validator/validator_function_test.cc
index 780b542..8440faa 100644
--- a/src/validator/validator_function_test.cc
+++ b/src/validator/validator_function_test.cc

@@ -237,7 +237,8 @@
   ast::ExpressionList call_params;
   auto* call_expr = create<ast::CallExpression>(
       Source{Source::Location{12, 34}},
-      create<ast::IdentifierExpression>("func"), call_params);
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("func"), "func"),
+      call_params);
   ast::VariableList params0;
   auto* body0 = create<ast::BlockStatement>();
   body0->append(create<ast::CallStatement>(call_expr));
@@ -258,7 +259,8 @@
   ast::ExpressionList call_params;
   auto* call_expr = create<ast::CallExpression>(
       Source{Source::Location{12, 34}},
-      create<ast::IdentifierExpression>("func"), call_params);
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("func"), "func"),
+      call_params);
   auto* var =
       create<ast::Variable>(Source{},                        // source
                             "a",                             // name
@@ -267,6 +269,7 @@
                             false,                           // is_const
                             call_expr,                       // constructor
                             ast::VariableDecorationList{});  // decorations
+
   ast::VariableList params0;
   auto* body0 = create<ast::BlockStatement>();
   body0->append(create<ast::VariableDeclStatement>(var));

diff --git a/src/validator/validator_test.cc b/src/validator/validator_test.cc
index 5931fc0..9c5c5d3 100644
--- a/src/validator/validator_test.cc
+++ b/src/validator/validator_test.cc

@@ -66,7 +66,8 @@
 
   auto* lhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1));
-  auto* rhs = create<ast::IdentifierExpression>("my_var");
+  auto* rhs = create<ast::IdentifierExpression>(mod()->RegisterSymbol("my_var"),
+                                                "my_var");
   ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs);
 
   // TODO(sarahM0): Invalidate assignment to scalar.
@@ -79,8 +80,8 @@
   // b = 2;
   ast::type::I32 i32;
 
-  auto* lhs =
-      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
+  auto* lhs = create<ast::IdentifierExpression>(
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
   auto* assign = create<ast::AssignmentStatement>(
@@ -97,8 +98,8 @@
   // }
   ast::type::I32 i32;
 
-  auto* lhs =
-      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
+  auto* lhs = create<ast::IdentifierExpression>(
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
 
@@ -125,7 +126,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
 
@@ -155,7 +157,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.3f));
 
@@ -188,7 +191,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
 
@@ -221,7 +225,8 @@
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.3f));
 
@@ -323,7 +328,8 @@
       ast::VariableDecorationList{}));            // decorations
 
   auto* lhs = create<ast::IdentifierExpression>(
-      Source{Source::Location{12, 34}}, "not_global_var");
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("not_global_var"),
+      "not_global_var");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.14f));
 
@@ -360,7 +366,8 @@
           create<ast::FloatLiteral>(&f32, 2.1)),  // constructor
       ast::VariableDecorationList{}));            // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("global_var");
+  auto* lhs = create<ast::IdentifierExpression>(
+      mod()->RegisterSymbol("global_var"), "global_var");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.14f));
 
@@ -404,8 +411,8 @@
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
 
-  auto* lhs =
-      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
+  auto* lhs = create<ast::IdentifierExpression>(
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.14f));
 
@@ -438,8 +445,8 @@
           create<ast::FloatLiteral>(&f32, 2.0)),  // constructor
       ast::VariableDecorationList{});             // decorations
 
-  auto* lhs =
-      create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
+  auto* lhs = create<ast::IdentifierExpression>(
+      Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.14f));
 
@@ -539,7 +546,8 @@
           create<ast::SintLiteral>(&i32, 2)),  // constructor
       ast::VariableDecorationList{});          // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
 
@@ -802,7 +810,8 @@
                             ast::VariableDecorationList{});  // decorations
 
   td()->RegisterVariableForTesting(var);
-  auto* lhs = create<ast::IdentifierExpression>("a");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
 

diff --git a/src/writer/hlsl/generator_impl_array_accessor_test.cc b/src/writer/hlsl/generator_impl_array_accessor_test.cc
index 53cee1a..ddf140c 100644
--- a/src/writer/hlsl/generator_impl_array_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_array_accessor_test.cc

@@ -33,7 +33,8 @@
   ast::type::I32 i32;
   auto* lit = create<ast::SintLiteral>(&i32, 5);
   auto* idx = create<ast::ScalarConstructorExpression>(lit);
-  auto* ary = create<ast::IdentifierExpression>("ary");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 
@@ -42,8 +43,10 @@
 }
 
 TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) {
-  auto* ary = create<ast::IdentifierExpression>("ary");
-  auto* idx = create<ast::IdentifierExpression>("idx");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 

diff --git a/src/writer/hlsl/generator_impl_assign_test.cc b/src/writer/hlsl/generator_impl_assign_test.cc
index a34d9ac..0b89944 100644
--- a/src/writer/hlsl/generator_impl_assign_test.cc
+++ b/src/writer/hlsl/generator_impl_assign_test.cc

@@ -28,8 +28,10 @@
 using HlslGeneratorImplTest_Assign = TestHelper;
 
 TEST_F(HlslGeneratorImplTest_Assign, Emit_Assign) {
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
   ast::AssignmentStatement assign(lhs, rhs);
 
   gen.increment_indent();

diff --git a/src/writer/hlsl/generator_impl_binary_test.cc b/src/writer/hlsl/generator_impl_binary_test.cc
index 318c68b..106d279 100644
--- a/src/writer/hlsl/generator_impl_binary_test.cc
+++ b/src/writer/hlsl/generator_impl_binary_test.cc

@@ -79,8 +79,10 @@
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
 
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   td.RegisterVariableForTesting(left_var);
   td.RegisterVariableForTesting(right_var);
@@ -113,8 +115,10 @@
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
 
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   td.RegisterVariableForTesting(left_var);
   td.RegisterVariableForTesting(right_var);
@@ -147,8 +151,10 @@
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
 
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   td.RegisterVariableForTesting(left_var);
   td.RegisterVariableForTesting(right_var);
@@ -243,7 +249,8 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f));
 
@@ -270,7 +277,8 @@
                             ast::VariableDecorationList{});  // decorations
   auto* lhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f));
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -294,7 +302,8 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
 
   ast::ExpressionList vals;
   vals.push_back(create<ast::ScalarConstructorExpression>(
@@ -337,7 +346,8 @@
       create<ast::FloatLiteral>(&f32, 1.f)));
   auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
 
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -361,8 +371,10 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -374,8 +386,10 @@
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, left, right);
 
@@ -390,10 +404,10 @@
 
 TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) {
   // (a && b) || (c || d)
-  auto* a = create<ast::IdentifierExpression>("a");
-  auto* b = create<ast::IdentifierExpression>("b");
-  auto* c = create<ast::IdentifierExpression>("c");
-  auto* d = create<ast::IdentifierExpression>("d");
+  auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
+  auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
+  auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
+  auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
 
   ast::BinaryExpression expr(
       ast::BinaryOp::kLogicalOr,
@@ -418,8 +432,10 @@
 }
 
 TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) {
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, left, right);
 
@@ -454,9 +470,10 @@
       Source{}, create<ast::ScalarConstructorExpression>(
                     create<ast::SintLiteral>(&i32, 2))));
   auto* else_if_stmt = create<ast::ElseStatement>(
-      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
-                                    create<ast::IdentifierExpression>("b"),
-                                    create<ast::IdentifierExpression>("c")),
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kLogicalOr,
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
       body);
 
   body = create<ast::BlockStatement>();
@@ -466,9 +483,10 @@
 
   ast::IfStatement expr(
       Source{},
-      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
-                                    create<ast::IdentifierExpression>("a"),
-                                    create<ast::IdentifierExpression>("b")),
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kLogicalAnd,
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
       body,
       {
           else_if_stmt,
@@ -498,9 +516,9 @@
 
 TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
   // return (a && b) || c;
-  auto* a = create<ast::IdentifierExpression>("a");
-  auto* b = create<ast::IdentifierExpression>("b");
-  auto* c = create<ast::IdentifierExpression>("c");
+  auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
+  auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
+  auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
 
   ast::ReturnStatement expr(
       Source{},
@@ -523,10 +541,10 @@
 
 TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
   // a = (b || c) && d;
-  auto* a = create<ast::IdentifierExpression>("a");
-  auto* b = create<ast::IdentifierExpression>("b");
-  auto* c = create<ast::IdentifierExpression>("c");
-  auto* d = create<ast::IdentifierExpression>("d");
+  auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
+  auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
+  auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
+  auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
 
   ast::AssignmentStatement expr(
       a,
@@ -551,9 +569,9 @@
   // var a : bool = (b && c) || d;
   ast::type::Bool bool_type;
 
-  auto* b = create<ast::IdentifierExpression>("b");
-  auto* c = create<ast::IdentifierExpression>("c");
-  auto* d = create<ast::IdentifierExpression>("d");
+  auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
+  auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
+  auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
 
   auto* var = create<ast::Variable>(
       Source{},                      // source
@@ -586,9 +604,9 @@
   // as<i32>(a && (b || c))
   ast::type::I32 i32;
 
-  auto* a = create<ast::IdentifierExpression>("a");
-  auto* b = create<ast::IdentifierExpression>("b");
-  auto* c = create<ast::IdentifierExpression>("c");
+  auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
+  auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
+  auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
 
   ast::BitcastExpression expr(&i32, create<ast::BinaryExpression>(
                                         ast::BinaryOp::kLogicalAnd, a,
@@ -620,22 +638,27 @@
 
   ast::ExpressionList params;
   params.push_back(create<ast::BinaryExpression>(
-      ast::BinaryOp::kLogicalAnd, create<ast::IdentifierExpression>("a"),
-      create<ast::IdentifierExpression>("b")));
+      ast::BinaryOp::kLogicalAnd,
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")));
   params.push_back(create<ast::BinaryExpression>(
-      ast::BinaryOp::kLogicalOr, create<ast::IdentifierExpression>("c"),
-      create<ast::IdentifierExpression>("d")));
+      ast::BinaryOp::kLogicalOr,
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d")));
   params.push_back(create<ast::BinaryExpression>(
       ast::BinaryOp::kLogicalAnd,
-      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
-                                    create<ast::IdentifierExpression>("a"),
-                                    create<ast::IdentifierExpression>("c")),
-      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
-                                    create<ast::IdentifierExpression>("b"),
-                                    create<ast::IdentifierExpression>("d"))));
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kLogicalOr,
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kLogicalOr,
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d"))));
 
   ast::CallStatement expr(create<ast::CallExpression>(
-      create<ast::IdentifierExpression>("foo"), params));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      params));
 
   ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
   EXPECT_EQ(result(), R"(bool _tint_tmp = a;

diff --git a/src/writer/hlsl/generator_impl_bitcast_test.cc b/src/writer/hlsl/generator_impl_bitcast_test.cc
index 9d6d214..a95de59 100644
--- a/src/writer/hlsl/generator_impl_bitcast_test.cc
+++ b/src/writer/hlsl/generator_impl_bitcast_test.cc

@@ -31,7 +31,7 @@
 
 TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Float) {
   ast::type::F32 f32;
-  auto* id = create<ast::IdentifierExpression>("id");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
   ast::BitcastExpression bitcast(&f32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
@@ -40,7 +40,7 @@
 
 TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
   ast::type::I32 i32;
-  auto* id = create<ast::IdentifierExpression>("id");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
   ast::BitcastExpression bitcast(&i32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
@@ -49,7 +49,7 @@
 
 TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
   ast::type::U32 u32;
-  auto* id = create<ast::IdentifierExpression>("id");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
   ast::BitcastExpression bitcast(&u32, id);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();

diff --git a/src/writer/hlsl/generator_impl_call_test.cc b/src/writer/hlsl/generator_impl_call_test.cc
index 3311837..14f9791 100644
--- a/src/writer/hlsl/generator_impl_call_test.cc
+++ b/src/writer/hlsl/generator_impl_call_test.cc

@@ -32,7 +32,8 @@
 TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::CallExpression call(id, {});
 
   auto* func = create<ast::Function>(
@@ -47,10 +48,13 @@
 TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
   ast::CallExpression call(id, params);
 
   auto* func = create<ast::Function>(
@@ -65,10 +69,13 @@
 TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
   ast::CallStatement call(create<ast::CallExpression>(id, params));
 
   auto* func = create<ast::Function>(

diff --git a/src/writer/hlsl/generator_impl_cast_test.cc b/src/writer/hlsl/generator_impl_cast_test.cc
index 1fc3c70..b53f3e0 100644
--- a/src/writer/hlsl/generator_impl_cast_test.cc
+++ b/src/writer/hlsl/generator_impl_cast_test.cc

@@ -32,7 +32,8 @@
   ast::type::F32 f32;
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("id"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
 
   ast::TypeConstructorExpression cast(&f32, params);
 
@@ -45,7 +46,8 @@
   ast::type::Vector vec3(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("id"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
 
   ast::TypeConstructorExpression cast(&vec3, params);
 

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 320b478..b25ae35 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

@@ -84,11 +84,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@@ -157,11 +157,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@@ -230,11 +230,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -302,11 +302,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -371,11 +371,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -435,11 +435,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -506,10 +506,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &void_type, body,

diff --git a/src/writer/hlsl/generator_impl_function_test.cc b/src/writer/hlsl/generator_impl_function_test.cc
index cab53fc..f05f0f7 100644
--- a/src/writer/hlsl/generator_impl_function_test.cc
+++ b/src/writer/hlsl/generator_impl_function_test.cc

@@ -171,8 +171,8 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("frag_main"), "frag_main", params,
@@ -241,10 +241,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("frag_main"), "frag_main", params,
@@ -304,8 +305,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
+                                            "x")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -375,9 +378,12 @@
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
           create<ast::MemberAccessorExpression>(
-              create<ast::IdentifierExpression>("uniforms"),
-              create<ast::IdentifierExpression>("coord")),
-          create<ast::IdentifierExpression>("x")),  // constructor
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("uniforms"),
+                                                "uniforms"),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                                "coord")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
+                                            "x")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -452,8 +458,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("b")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
+                                            "b")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -524,8 +532,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("b")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
+                                            "b")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -592,8 +602,9 @@
   ast::VariableList params;
   auto* assign = create<ast::AssignmentStatement>(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("b")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 2.0f)));
 
@@ -683,13 +694,14 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("val"),
-      create<ast::IdentifierExpression>("param")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("foo")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -702,9 +714,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func_1 = create<ast::Function>(
       Source{}, mod.RegisterSymbol("ep_1"), "ep_1", params, &void_type, body,
@@ -774,7 +788,8 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("param")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -787,9 +802,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func_1 = create<ast::Function>(
       Source{}, mod.RegisterSymbol("ep_1"), "ep_1", params, &void_type, body,
@@ -867,12 +884,14 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("param")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -885,9 +904,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func_1 = create<ast::Function>(
       Source{}, mod.RegisterSymbol("ep_1"), "ep_1", params, &void_type, body,
@@ -956,9 +977,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::MemberAccessorExpression>(
-                    create<ast::IdentifierExpression>("coord"),
-                    create<ast::IdentifierExpression>("x"))));
+      Source{},
+      create<ast::MemberAccessorExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -969,15 +992,17 @@
   expr.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* var = create<ast::Variable>(
-      Source{},                      // source
-      "v",                           // name
-      ast::StorageClass::kFunction,  // storage_class
-      &f32,                          // type
-      false,                         // is_const
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr),  // constructor
-      ast::VariableDecorationList{});     // decorations
+  auto* var =
+      create<ast::Variable>(Source{},                      // source
+                            "v",                           // name
+                            ast::StorageClass::kFunction,  // storage_class
+                            &f32,                          // type
+                            false,                         // is_const
+                            create<ast::CallExpression>(
+                                create<ast::IdentifierExpression>(
+                                    mod.RegisterSymbol("sub_func"), "sub_func"),
+                                expr),                       // constructor
+                            ast::VariableDecorationList{});  // decorations
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
@@ -1044,9 +1069,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::MemberAccessorExpression>(
-                    create<ast::IdentifierExpression>("coord"),
-                    create<ast::IdentifierExpression>("x"))));
+      Source{},
+      create<ast::MemberAccessorExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -1057,15 +1084,17 @@
   expr.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* var = create<ast::Variable>(
-      Source{},                      // source
-      "v",                           // name
-      ast::StorageClass::kFunction,  // storage_class
-      &f32,                          // type
-      false,                         // is_const
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr),  // constructor
-      ast::VariableDecorationList{});     // decorations
+  auto* var =
+      create<ast::Variable>(Source{},                      // source
+                            "v",                           // name
+                            ast::StorageClass::kFunction,  // storage_class
+                            &f32,                          // type
+                            false,                         // is_const
+                            create<ast::CallExpression>(
+                                create<ast::IdentifierExpression>(
+                                    mod.RegisterSymbol("sub_func"), "sub_func"),
+                                expr),                       // constructor
+                            ast::VariableDecorationList{});  // decorations
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
@@ -1119,7 +1148,7 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 1.0f))));
 
@@ -1326,8 +1355,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();
@@ -1352,8 +1383,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();

diff --git a/src/writer/hlsl/generator_impl_identifier_test.cc b/src/writer/hlsl/generator_impl_identifier_test.cc
index 2c0bfd2..c573ec4 100644
--- a/src/writer/hlsl/generator_impl_identifier_test.cc
+++ b/src/writer/hlsl/generator_impl_identifier_test.cc

@@ -24,14 +24,14 @@
 using HlslGeneratorImplTest_Identifier = TestHelper;
 
 TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
-  ast::IdentifierExpression i("foo");
+  ast::IdentifierExpression i(mod.RegisterSymbol("foo"), "foo");
   ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
   EXPECT_EQ(result(), "foo");
 }
 
 TEST_F(HlslGeneratorImplTest_Identifier,
        EmitIdentifierExpression_Single_WithCollision) {
-  ast::IdentifierExpression i("virtual");
+  ast::IdentifierExpression i(mod.RegisterSymbol("virtual"), "virtual");
   ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
   EXPECT_EQ(result(), "virtual_tint_0");
 }

diff --git a/src/writer/hlsl/generator_impl_if_test.cc b/src/writer/hlsl/generator_impl_if_test.cc
index c599362..9d4845f 100644
--- a/src/writer/hlsl/generator_impl_if_test.cc
+++ b/src/writer/hlsl/generator_impl_if_test.cc

@@ -27,7 +27,8 @@
 using HlslGeneratorImplTest_If = TestHelper;
 
 TEST_F(HlslGeneratorImplTest_If, Emit_If) {
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -42,11 +43,13 @@
 }
 
 TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -70,7 +73,8 @@
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -89,7 +93,8 @@
 }
 
 TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
 
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
@@ -97,7 +102,8 @@
   auto* else_body_2 = create<ast::BlockStatement>();
   else_body_2->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 

diff --git a/src/writer/hlsl/generator_impl_import_test.cc b/src/writer/hlsl/generator_impl_import_test.cc
index 09d9c2d..de3e4b5 100644
--- a/src/writer/hlsl/generator_impl_import_test.cc
+++ b/src/writer/hlsl/generator_impl_import_test.cc

@@ -56,7 +56,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol(param.name), param.name);
   ast::CallExpression expr(ident, params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -101,7 +102,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -124,7 +126,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.f)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -169,7 +172,8 @@
                     create<ast::FloatLiteral>(&f32, 6.f)),
             }));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -194,7 +198,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -220,7 +225,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.f)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -253,7 +259,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 3)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -278,10 +285,13 @@
                             ast::VariableDecorationList{});  // decorations
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("var"), "var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("determinant"),
-                           params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("determinant"),
+                                        "determinant"),
+      params);
 
   mod.AddGlobalVariable(var);
 

diff --git a/src/writer/hlsl/generator_impl_intrinsic_test.cc b/src/writer/hlsl/generator_impl_intrinsic_test.cc
index 5287180..375aa9b 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_test.cc

@@ -93,11 +93,15 @@
                             ast::VariableDecorationList{});  // decorations
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("a"));
-  params.push_back(create<ast::IdentifierExpression>("b"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("outer_product"),
-                           params);
+  ast::CallExpression call(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("outer_product"),
+                                        "outer_product"),
+      params);
 
   td.RegisterVariableForTesting(a);
   td.RegisterVariableForTesting(b);
@@ -122,10 +126,14 @@
   ast::type::Vector vec(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("dot"), params);
+  ast::CallExpression call(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("dot"), "dot"),
+      params);
 
   ast::Variable v1(Source{}, "param1", ast::StorageClass::kFunction, &vec,
                    false, nullptr, ast::VariableDecorationList{});

diff --git a/src/writer/hlsl/generator_impl_loop_test.cc b/src/writer/hlsl/generator_impl_loop_test.cc
index 383442e..b06f1bc 100644
--- a/src/writer/hlsl/generator_impl_loop_test.cc
+++ b/src/writer/hlsl/generator_impl_loop_test.cc

@@ -86,8 +86,10 @@
   body = create<ast::BlockStatement>();
   body->append(inner);
 
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   continuing = create<ast::BlockStatement>();
   continuing->append(create<ast::AssignmentStatement>(lhs, rhs));
@@ -165,8 +167,10 @@
                             nullptr,                           // constructor
                             ast::VariableDecorationList{})));  // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   auto* continuing = create<ast::BlockStatement>();
   continuing->append(create<ast::AssignmentStatement>(lhs, rhs));

diff --git a/src/writer/hlsl/generator_impl_member_accessor_test.cc b/src/writer/hlsl/generator_impl_member_accessor_test.cc
index ccf706d..8bbc18e 100644
--- a/src/writer/hlsl/generator_impl_member_accessor_test.cc
+++ b/src/writer/hlsl/generator_impl_member_accessor_test.cc

@@ -66,8 +66,10 @@
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
 
-  auto* str = create<ast::IdentifierExpression>("str");
-  auto* mem = create<ast::IdentifierExpression>("mem");
+  auto* str =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("str"), "str");
+  auto* mem =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mem"), "mem");
 
   ast::MemberAccessorExpression expr(str, mem);
 
@@ -115,8 +117,9 @@
                             nullptr,                            // constructor
                             ast::VariableDecorationList{});     // decorations
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("b"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
   td.RegisterVariableForTesting(coord_var);
   gen.register_global(coord_var);
@@ -164,8 +167,9 @@
                             nullptr,                            // constructor
                             ast::VariableDecorationList{});     // decorations
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("a"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(coord_var);
   gen.register_global(coord_var);
@@ -226,9 +230,9 @@
                             ast::VariableDecorationList{});     // decorations
 
   auto* lhs = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("data"),
-      create<ast::IdentifierExpression>("a"));
-  auto* rhs = create<ast::IdentifierExpression>("b");
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
+  auto* rhs = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
 
   ast::AssignmentStatement assign(lhs, rhs);
 
@@ -289,8 +293,8 @@
                             ast::VariableDecorationList{});     // decorations
 
   auto* lhs = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("data"),
-      create<ast::IdentifierExpression>("a"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
   auto* rhs =
       create<ast::TypeConstructorExpression>(&mat, ast::ExpressionList{});
 
@@ -349,8 +353,9 @@
                             nullptr,                            // constructor
                             ast::VariableDecorationList{});     // decorations
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("a"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(coord_var);
   gen.register_global(coord_var);
@@ -405,8 +410,9 @@
                             nullptr,                            // constructor
                             ast::VariableDecorationList{});     // decorations
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("a"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(coord_var);
   gen.register_global(coord_var);
@@ -453,8 +459,9 @@
                             nullptr,                            // constructor
                             ast::VariableDecorationList{});     // decorations
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("a"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(coord_var);
   gen.register_global(coord_var);
@@ -508,8 +515,9 @@
   ast::ArrayAccessorExpression expr(
       create<ast::ArrayAccessorExpression>(
           create<ast::MemberAccessorExpression>(
-              create<ast::IdentifierExpression>("data"),
-              create<ast::IdentifierExpression>("a")),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                "data"),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
           create<ast::ScalarConstructorExpression>(
               create<ast::SintLiteral>(&i32, 2))),
       create<ast::ScalarConstructorExpression>(
@@ -562,8 +570,8 @@
 
   ast::ArrayAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("data"),
-          create<ast::IdentifierExpression>("a")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 2)));
 
@@ -614,8 +622,8 @@
 
   ast::ArrayAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("data"),
-          create<ast::IdentifierExpression>("a")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
       create<ast::BinaryExpression>(
           ast::BinaryOp::kSubtract,
           create<ast::BinaryExpression>(
@@ -681,8 +689,8 @@
   ASSERT_TRUE(td.Determine()) << td.error();
 
   auto* lhs = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("data"),
-      create<ast::IdentifierExpression>("b"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.0f));
   ast::AssignmentStatement assign(lhs, rhs);
@@ -736,8 +744,8 @@
 
   auto* lhs = create<ast::ArrayAccessorExpression>(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("data"),
-          create<ast::IdentifierExpression>("a")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 2)));
   auto* rhs = create<ast::ScalarConstructorExpression>(
@@ -793,8 +801,8 @@
   ASSERT_TRUE(td.Determine()) << td.error();
 
   auto* lhs = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("data"),
-      create<ast::IdentifierExpression>("a"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2));
   ast::AssignmentStatement assign(lhs, rhs);
@@ -849,8 +857,9 @@
 
   ASSERT_TRUE(td.Determine()) << td.error();
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
-                                     create<ast::IdentifierExpression>("b"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@@ -910,8 +919,8 @@
   values.push_back(create<ast::ScalarConstructorExpression>(lit3));
 
   auto* lhs = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("data"),
-      create<ast::IdentifierExpression>("b"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
   auto* rhs = create<ast::TypeConstructorExpression>(&fvec3, values);
 
   ast::AssignmentStatement assign(lhs, rhs);
@@ -988,11 +997,12 @@
   ast::MemberAccessorExpression expr(
       create<ast::ArrayAccessorExpression>(
           create<ast::MemberAccessorExpression>(
-              create<ast::IdentifierExpression>("data"),
-              create<ast::IdentifierExpression>("c")),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                "data"),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
           create<ast::ScalarConstructorExpression>(
               create<ast::SintLiteral>(&i32, 2))),
-      create<ast::IdentifierExpression>("b"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@@ -1066,12 +1076,14 @@
       create<ast::MemberAccessorExpression>(
           create<ast::ArrayAccessorExpression>(
               create<ast::MemberAccessorExpression>(
-                  create<ast::IdentifierExpression>("data"),
-                  create<ast::IdentifierExpression>("c")),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                    "data"),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
+                                                    "c")),
               create<ast::ScalarConstructorExpression>(
                   create<ast::SintLiteral>(&i32, 2))),
-          create<ast::IdentifierExpression>("b")),
-      create<ast::IdentifierExpression>("xy"));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("xy"), "xy"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@@ -1144,12 +1156,14 @@
       create<ast::MemberAccessorExpression>(
           create<ast::ArrayAccessorExpression>(
               create<ast::MemberAccessorExpression>(
-                  create<ast::IdentifierExpression>("data"),
-                  create<ast::IdentifierExpression>("c")),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                    "data"),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
+                                                    "c")),
               create<ast::ScalarConstructorExpression>(
                   create<ast::SintLiteral>(&i32, 2))),
-          create<ast::IdentifierExpression>("b")),
-      create<ast::IdentifierExpression>("g"));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("g"), "g"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr));
   ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@@ -1221,11 +1235,13 @@
       create<ast::MemberAccessorExpression>(
           create<ast::ArrayAccessorExpression>(
               create<ast::MemberAccessorExpression>(
-                  create<ast::IdentifierExpression>("data"),
-                  create<ast::IdentifierExpression>("c")),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                    "data"),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
+                                                    "c")),
               create<ast::ScalarConstructorExpression>(
                   create<ast::SintLiteral>(&i32, 2))),
-          create<ast::IdentifierExpression>("b")),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 1)));
 
@@ -1298,11 +1314,12 @@
   auto* lhs = create<ast::MemberAccessorExpression>(
       create<ast::ArrayAccessorExpression>(
           create<ast::MemberAccessorExpression>(
-              create<ast::IdentifierExpression>("data"),
-              create<ast::IdentifierExpression>("c")),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                "data"),
+              create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
           create<ast::ScalarConstructorExpression>(
               create<ast::SintLiteral>(&i32, 2))),
-      create<ast::IdentifierExpression>("b"));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
   auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f);
   auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f);
@@ -1388,12 +1405,14 @@
       create<ast::MemberAccessorExpression>(
           create<ast::ArrayAccessorExpression>(
               create<ast::MemberAccessorExpression>(
-                  create<ast::IdentifierExpression>("data"),
-                  create<ast::IdentifierExpression>("c")),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                                    "data"),
+                  create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
+                                                    "c")),
               create<ast::ScalarConstructorExpression>(
                   create<ast::SintLiteral>(&i32, 2))),
-          create<ast::IdentifierExpression>("b")),
-      create<ast::IdentifierExpression>("y"));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("y"), "y"));
 
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&i32, 1.f));

diff --git a/src/writer/hlsl/generator_impl_return_test.cc b/src/writer/hlsl/generator_impl_return_test.cc
index d2a6ad6..0b54dc0 100644
--- a/src/writer/hlsl/generator_impl_return_test.cc
+++ b/src/writer/hlsl/generator_impl_return_test.cc

@@ -36,7 +36,8 @@
 }
 
 TEST_F(HlslGeneratorImplTest_Return, Emit_ReturnWithValue) {
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::ReturnStatement r(Source{}, expr);
   gen.increment_indent();
 

diff --git a/src/writer/hlsl/generator_impl_switch_test.cc b/src/writer/hlsl/generator_impl_switch_test.cc
index fa5f12d..7e8ef38 100644
--- a/src/writer/hlsl/generator_impl_switch_test.cc
+++ b/src/writer/hlsl/generator_impl_switch_test.cc

@@ -48,7 +48,8 @@
   body.push_back(case_stmt);
   body.push_back(def);
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   ast::SwitchStatement s(cond, body);
   gen.increment_indent();
 

diff --git a/src/writer/hlsl/generator_impl_test.cc b/src/writer/hlsl/generator_impl_test.cc
index 1494fcf..c93304a 100644
--- a/src/writer/hlsl/generator_impl_test.cc
+++ b/src/writer/hlsl/generator_impl_test.cc

@@ -56,7 +56,8 @@
 TEST_F(HlslGeneratorImplTest, NameConflictWith_InputStructName) {
   ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 
-  ast::IdentifierExpression ident("func_main_in");
+  ast::IdentifierExpression ident(mod.RegisterSymbol("func_main_in"),
+                                  "func_main_in");
   ASSERT_TRUE(gen.EmitIdentifier(pre, out, &ident));
   EXPECT_EQ(result(), "func_main_in_0");
 }

diff --git a/src/writer/hlsl/generator_impl_unary_op_test.cc b/src/writer/hlsl/generator_impl_unary_op_test.cc
index 7b9ed5f..8a87e93 100644
--- a/src/writer/hlsl/generator_impl_unary_op_test.cc
+++ b/src/writer/hlsl/generator_impl_unary_op_test.cc

@@ -37,7 +37,8 @@
 TEST_P(HlslUnaryOpTest, Emit) {
   auto params = GetParam();
 
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::UnaryOpExpression op(params.op, expr);
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, &op)) << gen.error();

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 35e2387..a360918 100644
--- a/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/hlsl/generator_impl_variable_decl_statement_test.cc

@@ -127,7 +127,8 @@
 
 TEST_F(HlslGeneratorImplTest_VariableDecl,
        Emit_VariableDeclStatement_Initializer_Private) {
-  auto* ident = create<ast::IdentifierExpression>("initializer");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("initializer"), "initializer");
 
   ast::type::F32 f32;
   auto* var =

diff --git a/src/writer/msl/generator_impl_array_accessor_test.cc b/src/writer/msl/generator_impl_array_accessor_test.cc
index a584f80..1560773 100644
--- a/src/writer/msl/generator_impl_array_accessor_test.cc
+++ b/src/writer/msl/generator_impl_array_accessor_test.cc

@@ -35,7 +35,8 @@
   ast::type::I32 i32;
   auto* lit = create<ast::SintLiteral>(&i32, 5);
   auto* idx = create<ast::ScalarConstructorExpression>(lit);
-  auto* ary = create<ast::IdentifierExpression>("ary");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 
@@ -44,8 +45,10 @@
 }
 
 TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
-  auto* ary = create<ast::IdentifierExpression>("ary");
-  auto* idx = create<ast::IdentifierExpression>("idx");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 

diff --git a/src/writer/msl/generator_impl_assign_test.cc b/src/writer/msl/generator_impl_assign_test.cc
index eb673fe..44df0fa 100644
--- a/src/writer/msl/generator_impl_assign_test.cc
+++ b/src/writer/msl/generator_impl_assign_test.cc

@@ -30,8 +30,10 @@
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Assign) {
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
   ast::AssignmentStatement assign(lhs, rhs);
 
   gen.increment_indent();

diff --git a/src/writer/msl/generator_impl_binary_test.cc b/src/writer/msl/generator_impl_binary_test.cc
index 62e48ad..dc378bd 100644
--- a/src/writer/msl/generator_impl_binary_test.cc
+++ b/src/writer/msl/generator_impl_binary_test.cc

@@ -38,8 +38,10 @@
 TEST_P(MslBinaryTest, Emit) {
   auto params = GetParam();
 
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   ast::BinaryExpression expr(params.op, left, right);
 

diff --git a/src/writer/msl/generator_impl_bitcast_test.cc b/src/writer/msl/generator_impl_bitcast_test.cc
index d6c1546..bba7e43 100644
--- a/src/writer/msl/generator_impl_bitcast_test.cc
+++ b/src/writer/msl/generator_impl_bitcast_test.cc

@@ -31,7 +31,7 @@
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
   ast::type::F32 f32;
-  auto* id = create<ast::IdentifierExpression>("id");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
   ast::BitcastExpression bitcast(&f32, id);
 
   ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();

diff --git a/src/writer/msl/generator_impl_call_test.cc b/src/writer/msl/generator_impl_call_test.cc
index 7102424..897a819 100644
--- a/src/writer/msl/generator_impl_call_test.cc
+++ b/src/writer/msl/generator_impl_call_test.cc

@@ -34,7 +34,8 @@
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::CallExpression call(id, {});
 
   auto* func = create<ast::Function>(
@@ -49,10 +50,13 @@
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
   ast::CallExpression call(id, params);
 
   auto* func = create<ast::Function>(
@@ -67,10 +71,13 @@
 TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
   ast::type::Void void_type;
 
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
   ast::CallStatement call(create<ast::CallExpression>(id, params));
 
   auto* func = create<ast::Function>(

diff --git a/src/writer/msl/generator_impl_cast_test.cc b/src/writer/msl/generator_impl_cast_test.cc
index 22ebedf..c63fef3 100644
--- a/src/writer/msl/generator_impl_cast_test.cc
+++ b/src/writer/msl/generator_impl_cast_test.cc

@@ -34,7 +34,8 @@
   ast::type::F32 f32;
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("id"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
 
   ast::TypeConstructorExpression cast(&f32, params);
 
@@ -47,7 +48,8 @@
   ast::type::Vector vec3(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("id"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
 
   ast::TypeConstructorExpression cast(&vec3, params);
 

diff --git a/src/writer/msl/generator_impl_function_entry_point_data_test.cc b/src/writer/msl/generator_impl_function_entry_point_data_test.cc
index f43ea32..eaf49e3 100644
--- a/src/writer/msl/generator_impl_function_entry_point_data_test.cc
+++ b/src/writer/msl/generator_impl_function_entry_point_data_test.cc

@@ -83,11 +83,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@@ -153,11 +153,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@@ -223,11 +223,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
       ast::FunctionDecorationList{
@@ -292,11 +292,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -359,11 +359,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -421,11 +421,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("foo"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@@ -490,10 +490,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
 
   auto* func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("main"), "main", params, &void_type, body,

diff --git a/src/writer/msl/generator_impl_function_test.cc b/src/writer/msl/generator_impl_function_test.cc
index 950e8fe..680441f 100644
--- a/src/writer/msl/generator_impl_function_test.cc
+++ b/src/writer/msl/generator_impl_function_test.cc

@@ -179,8 +179,8 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::ReturnStatement>(Source{}));
 
   auto* func = create<ast::Function>(
@@ -252,10 +252,11 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   body->append(create<ast::ReturnStatement>(Source{}));
 
   auto* func = create<ast::Function>(
@@ -315,8 +316,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
+                                            "x")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -392,8 +395,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("b")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
+                                            "b")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -474,8 +479,10 @@
       &f32,                          // type
       false,                         // is_const
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("b")),  // constructor
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
+                                            "b")),  // constructor
       ast::VariableDecorationList{});               // decorations
 
   auto* body = create<ast::BlockStatement>();
@@ -571,13 +578,14 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("val"),
-      create<ast::IdentifierExpression>("param")));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("val"), "val"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("foo")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -590,9 +598,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func_1 = create<ast::Function>(
       Source{}, mod.RegisterSymbol("ep_1"), "ep_1", params, &void_type, body,
@@ -665,7 +675,8 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("param")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -678,9 +689,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
 
   auto* func_1 = create<ast::Function>(
@@ -762,12 +775,14 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("coord"),
-          create<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("param")));
+      Source{},
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -780,9 +795,11 @@
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("depth"),
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr)));
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
+      create<ast::CallExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
+                                            "sub_func"),
+          expr)));
   body->append(create<ast::ReturnStatement>(Source{}));
   auto* func_1 = create<ast::Function>(
       Source{}, mod.RegisterSymbol("ep_1"), "ep_1", params, &void_type, body,
@@ -849,9 +866,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::MemberAccessorExpression>(
-                    create<ast::IdentifierExpression>("coord"),
-                    create<ast::IdentifierExpression>("x"))));
+      Source{},
+      create<ast::MemberAccessorExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -862,15 +881,17 @@
   expr.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* var = create<ast::Variable>(
-      Source{},                      // source
-      "v",                           // name
-      ast::StorageClass::kFunction,  // storage_class
-      &f32,                          // type
-      false,                         // is_const
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr),  // constructor
-      ast::VariableDecorationList{});     // decorations
+  auto* var =
+      create<ast::Variable>(Source{},                      // source
+                            "v",                           // name
+                            ast::StorageClass::kFunction,  // storage_class
+                            &f32,                          // type
+                            false,                         // is_const
+                            create<ast::CallExpression>(
+                                create<ast::IdentifierExpression>(
+                                    mod.RegisterSymbol("sub_func"), "sub_func"),
+                                expr),                       // constructor
+                            ast::VariableDecorationList{});  // decorations
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
@@ -951,9 +972,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::MemberAccessorExpression>(
-                    create<ast::IdentifierExpression>("coord"),
-                    create<ast::IdentifierExpression>("b"))));
+      Source{},
+      create<ast::MemberAccessorExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"))));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -964,15 +987,17 @@
   expr.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* var = create<ast::Variable>(
-      Source{},                      // source
-      "v",                           // name
-      ast::StorageClass::kFunction,  // storage_class
-      &f32,                          // type
-      false,                         // is_const
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr),  // constructor
-      ast::VariableDecorationList{});     // decorations
+  auto* var =
+      create<ast::Variable>(Source{},                      // source
+                            "v",                           // name
+                            ast::StorageClass::kFunction,  // storage_class
+                            &f32,                          // type
+                            false,                         // is_const
+                            create<ast::CallExpression>(
+                                create<ast::IdentifierExpression>(
+                                    mod.RegisterSymbol("sub_func"), "sub_func"),
+                                expr),                       // constructor
+                            ast::VariableDecorationList{});  // decorations
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
@@ -1059,9 +1084,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::MemberAccessorExpression>(
-                    create<ast::IdentifierExpression>("coord"),
-                    create<ast::IdentifierExpression>("b"))));
+      Source{},
+      create<ast::MemberAccessorExpression>(
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
+                                            "coord"),
+          create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"))));
   auto* sub_func = create<ast::Function>(
       Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
       ast::FunctionDecorationList{});
@@ -1072,15 +1099,17 @@
   expr.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f)));
 
-  auto* var = create<ast::Variable>(
-      Source{},                      // source
-      "v",                           // name
-      ast::StorageClass::kFunction,  // storage_class
-      &f32,                          // type
-      false,                         // is_const
-      create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
-                                  expr),  // constructor
-      ast::VariableDecorationList{});     // decorations
+  auto* var =
+      create<ast::Variable>(Source{},                      // source
+                            "v",                           // name
+                            ast::StorageClass::kFunction,  // storage_class
+                            &f32,                          // type
+                            false,                         // is_const
+                            create<ast::CallExpression>(
+                                create<ast::IdentifierExpression>(
+                                    mod.RegisterSymbol("sub_func"), "sub_func"),
+                                expr),                       // constructor
+                            ast::VariableDecorationList{});  // decorations
 
   body = create<ast::BlockStatement>();
   body->append(create<ast::VariableDeclStatement>(var));
@@ -1141,7 +1170,7 @@
   ast::VariableList params;
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 1.0f))));
 
@@ -1306,8 +1335,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();
@@ -1333,8 +1364,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();

diff --git a/src/writer/msl/generator_impl_identifier_test.cc b/src/writer/msl/generator_impl_identifier_test.cc
index d5be38b..94f6be8 100644
--- a/src/writer/msl/generator_impl_identifier_test.cc
+++ b/src/writer/msl/generator_impl_identifier_test.cc

@@ -26,14 +26,14 @@
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) {
-  ast::IdentifierExpression i("foo");
+  ast::IdentifierExpression i(mod.RegisterSymbol("foo"), "foo");
 
   ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
   EXPECT_EQ(gen.result(), "foo");
 }
 
 TEST_F(MslGeneratorImplTest, EmitIdentifierExpression_Single_WithCollision) {
-  ast::IdentifierExpression i("virtual");
+  ast::IdentifierExpression i(mod.RegisterSymbol("virtual"), "virtual");
 
   ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
   EXPECT_EQ(gen.result(), "virtual_tint_0");

diff --git a/src/writer/msl/generator_impl_if_test.cc b/src/writer/msl/generator_impl_if_test.cc
index 3a86c4d..be01567 100644
--- a/src/writer/msl/generator_impl_if_test.cc
+++ b/src/writer/msl/generator_impl_if_test.cc

@@ -29,7 +29,8 @@
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_If) {
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -45,11 +46,13 @@
 }
 
 TEST_F(MslGeneratorImplTest, Emit_IfWithElseIf) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -71,7 +74,8 @@
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 
@@ -90,7 +94,8 @@
 }
 
 TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
 
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::ReturnStatement>(Source{}));
@@ -98,7 +103,8 @@
   auto* else_body_2 = create<ast::BlockStatement>();
   else_body_2->append(create<ast::ReturnStatement>(Source{}));
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(Source{}));
 

diff --git a/src/writer/msl/generator_impl_import_test.cc b/src/writer/msl/generator_impl_import_test.cc
index 76b5e1c..d543348 100644
--- a/src/writer/msl/generator_impl_import_test.cc
+++ b/src/writer/msl/generator_impl_import_test.cc

@@ -57,7 +57,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto* ident = create<ast::IdentifierExpression>(param.name);
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol(param.name), param.name);
 
   ast::CallExpression call(ident, params);
 
@@ -100,7 +101,9 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("abs"), params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("abs"), "abs"),
+      params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
@@ -120,7 +123,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.f)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -168,7 +172,8 @@
                     create<ast::FloatLiteral>(&f32, 6.f)),
             }));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -193,7 +198,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 2)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -219,7 +225,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 3.f)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -250,7 +257,8 @@
   params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 3)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod.RegisterSymbol(param.name), param.name),
                            params);
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -277,10 +285,13 @@
                             ast::VariableDecorationList{});  // decorations
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("var"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("var"), "var"));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("determinant"),
-                           params);
+  ast::CallExpression expr(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("determinant"),
+                                        "determinant"),
+      params);
 
   mod.AddGlobalVariable(var);
 

diff --git a/src/writer/msl/generator_impl_intrinsic_test.cc b/src/writer/msl/generator_impl_intrinsic_test.cc
index 33b5a63..c819943 100644
--- a/src/writer/msl/generator_impl_intrinsic_test.cc
+++ b/src/writer/msl/generator_impl_intrinsic_test.cc

@@ -88,11 +88,15 @@
                             ast::VariableDecorationList{});  // decorations
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("a"));
-  params.push_back(create<ast::IdentifierExpression>("b"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("outer_product"),
-                           params);
+  ast::CallExpression call(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("outer_product"),
+                                        "outer_product"),
+      params);
 
   td.RegisterVariableForTesting(a);
   td.RegisterVariableForTesting(b);
@@ -117,10 +121,14 @@
   ast::type::Vector vec(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
 
-  ast::CallExpression call(create<ast::IdentifierExpression>("dot"), params);
+  ast::CallExpression call(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("dot"), "dot"),
+      params);
 
   ast::Variable v1(Source{}, "param1", ast::StorageClass::kFunction, &vec,
                    false, nullptr, ast::VariableDecorationList{});

diff --git a/src/writer/msl/generator_impl_loop_test.cc b/src/writer/msl/generator_impl_loop_test.cc
index fa18cb3..b6c91fd 100644
--- a/src/writer/msl/generator_impl_loop_test.cc
+++ b/src/writer/msl/generator_impl_loop_test.cc

@@ -90,8 +90,10 @@
   body = create<ast::BlockStatement>();
   body->append(inner);
 
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   continuing = create<ast::BlockStatement>();
   continuing->append(create<ast::AssignmentStatement>(lhs, rhs));
@@ -170,8 +172,10 @@
                             nullptr,                           // constructor
                             ast::VariableDecorationList{})));  // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
 
   auto* continuing = create<ast::BlockStatement>();
   continuing->append(create<ast::AssignmentStatement>(lhs, rhs));

diff --git a/src/writer/msl/generator_impl_member_accessor_test.cc b/src/writer/msl/generator_impl_member_accessor_test.cc
index 7672a01..643f34e 100644
--- a/src/writer/msl/generator_impl_member_accessor_test.cc
+++ b/src/writer/msl/generator_impl_member_accessor_test.cc

@@ -29,8 +29,10 @@
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
-  auto* str = create<ast::IdentifierExpression>("str");
-  auto* mem = create<ast::IdentifierExpression>("mem");
+  auto* str =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("str"), "str");
+  auto* mem =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mem"), "mem");
 
   ast::MemberAccessorExpression expr(str, mem);
 

diff --git a/src/writer/msl/generator_impl_return_test.cc b/src/writer/msl/generator_impl_return_test.cc
index be2138e..c285996 100644
--- a/src/writer/msl/generator_impl_return_test.cc
+++ b/src/writer/msl/generator_impl_return_test.cc

@@ -39,7 +39,8 @@
 }
 
 TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::ReturnStatement r(Source{}, expr);
 
   gen.increment_indent();

diff --git a/src/writer/msl/generator_impl_switch_test.cc b/src/writer/msl/generator_impl_switch_test.cc
index 88dd603..fd69599 100644
--- a/src/writer/msl/generator_impl_switch_test.cc
+++ b/src/writer/msl/generator_impl_switch_test.cc

@@ -50,7 +50,8 @@
   body.push_back(case_stmt);
   body.push_back(def);
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   ast::SwitchStatement s(cond, body);
 
   gen.increment_indent();

diff --git a/src/writer/msl/generator_impl_test.cc b/src/writer/msl/generator_impl_test.cc
index 0ba3247..de0bbf2 100644
--- a/src/writer/msl/generator_impl_test.cc
+++ b/src/writer/msl/generator_impl_test.cc

@@ -79,7 +79,8 @@
 TEST_F(MslGeneratorImplTest, NameConflictWith_InputStructName) {
   ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
 
-  ast::IdentifierExpression ident("func_main_in");
+  ast::IdentifierExpression ident(mod.RegisterSymbol("func_main_in"),
+                                  "func_main_in");
   ASSERT_TRUE(gen.EmitIdentifier(&ident));
   EXPECT_EQ(gen.result(), "func_main_in_0");
 }

diff --git a/src/writer/msl/generator_impl_unary_op_test.cc b/src/writer/msl/generator_impl_unary_op_test.cc
index a676558..d054bce 100644
--- a/src/writer/msl/generator_impl_unary_op_test.cc
+++ b/src/writer/msl/generator_impl_unary_op_test.cc

@@ -39,7 +39,8 @@
 TEST_P(MslUnaryOpTest, Emit) {
   auto params = GetParam();
 
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::UnaryOpExpression op(params.op, expr);
 
   ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();

diff --git a/src/writer/msl/generator_impl_variable_decl_statement_test.cc b/src/writer/msl/generator_impl_variable_decl_statement_test.cc
index 8397d50..50a2830 100644
--- a/src/writer/msl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/msl/generator_impl_variable_decl_statement_test.cc

@@ -193,7 +193,8 @@
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
-  auto* ident = create<ast::IdentifierExpression>("initializer");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("initializer"), "initializer");
 
   ast::type::F32 f32;
   auto* var =

diff --git a/src/writer/spirv/builder_accessor_expression_test.cc b/src/writer/spirv/builder_accessor_expression_test.cc
index f46d48e..6fbdbf5 100644
--- a/src/writer/spirv/builder_accessor_expression_test.cc
+++ b/src/writer/spirv/builder_accessor_expression_test.cc

@@ -56,7 +56,8 @@
   ast::Variable var(Source{}, "ary", ast::StorageClass::kFunction, &vec3, false,
                     nullptr, ast::VariableDecorationList{});
 
-  auto* ary = create<ast::IdentifierExpression>("ary");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
   auto* idx_expr = create<ast::ScalarConstructorExpression>(
       create<ast::SintLiteral>(&i32, 1));
 
@@ -100,8 +101,10 @@
   ast::Variable idx(Source{}, "idx", ast::StorageClass::kFunction, &i32, false,
                     nullptr, ast::VariableDecorationList{});
 
-  auto* ary = create<ast::IdentifierExpression>("ary");
-  auto* idx_expr = create<ast::IdentifierExpression>("idx");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
+  auto* idx_expr =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("idx"), "idx");
 
   ast::ArrayAccessorExpression expr(ary, idx_expr);
 
@@ -145,7 +148,8 @@
   ast::Variable var(Source{}, "ary", ast::StorageClass::kFunction, &vec3, false,
                     nullptr, ast::VariableDecorationList{});
 
-  auto* ary = create<ast::IdentifierExpression>("ary");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
 
   ast::ArrayAccessorExpression expr(
       ary,
@@ -195,7 +199,7 @@
 
   ast::ArrayAccessorExpression expr(
       create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("ary"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
           create<ast::ScalarConstructorExpression>(
               create<ast::SintLiteral>(&i32, 3))),
       create<ast::ScalarConstructorExpression>(
@@ -243,10 +247,10 @@
 
   ast::MemberAccessorExpression expr(
       create<ast::ArrayAccessorExpression>(
-          create<ast::IdentifierExpression>("ary"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
           create<ast::ScalarConstructorExpression>(
               create<ast::SintLiteral>(&i32, 2))),
-      create<ast::IdentifierExpression>("xy"));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("xy"), "xy"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -298,8 +302,9 @@
   ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &s_type,
                     false, nullptr, ast::VariableDecorationList{});
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
-                                     create<ast::IdentifierExpression>("b"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -355,9 +360,11 @@
 
   ast::MemberAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("inner")),
-      create<ast::IdentifierExpression>("a"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
+                                            "inner")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -416,9 +423,11 @@
 
   ast::MemberAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("inner")),
-      create<ast::IdentifierExpression>("a"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
+                                            "inner")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -476,9 +485,11 @@
 
   auto* lhs = create<ast::MemberAccessorExpression>(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("inner")),
-      create<ast::IdentifierExpression>("a"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
+                                            "inner")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
 
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 2.f));
@@ -543,13 +554,16 @@
   ast::Variable store(Source{}, "store", ast::StorageClass::kFunction, &f32,
                       false, nullptr, ast::VariableDecorationList{});
 
-  auto* lhs = create<ast::IdentifierExpression>("store");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("store"), "store");
 
   auto* rhs = create<ast::MemberAccessorExpression>(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("inner")),
-      create<ast::IdentifierExpression>("a"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
+                                            "inner")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
 
   ast::AssignmentStatement expr(lhs, rhs);
 
@@ -593,8 +607,9 @@
   ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &vec3,
                     false, nullptr, ast::VariableDecorationList{});
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
-                                     create<ast::IdentifierExpression>("y"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -629,8 +644,9 @@
   ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &vec3,
                     false, nullptr, ast::VariableDecorationList{});
 
-  ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
-                                     create<ast::IdentifierExpression>("yx"));
+  ast::MemberAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("yx"), "yx"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -666,9 +682,10 @@
 
   ast::MemberAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("yxz")),
-      create<ast::IdentifierExpression>("xz"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("xz"), "xz"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -705,9 +722,10 @@
 
   ast::MemberAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("yxz")),
-      create<ast::IdentifierExpression>("x"));
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("x"), "x"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -744,8 +762,9 @@
 
   ast::ArrayAccessorExpression expr(
       create<ast::MemberAccessorExpression>(
-          create<ast::IdentifierExpression>("ident"),
-          create<ast::IdentifierExpression>("yxz")),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
+                                            "ident"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 1)));
 
@@ -818,15 +837,18 @@
               create<ast::ArrayAccessorExpression>(
                   create<ast::MemberAccessorExpression>(
                       create<ast::ArrayAccessorExpression>(
-                          create<ast::IdentifierExpression>("index"),
+                          create<ast::IdentifierExpression>(
+                              mod->RegisterSymbol("index"), "index"),
                           create<ast::ScalarConstructorExpression>(
                               create<ast::SintLiteral>(&i32, 0))),
-                      create<ast::IdentifierExpression>("foo")),
+                      create<ast::IdentifierExpression>(
+                          mod->RegisterSymbol("foo"), "foo")),
                   create<ast::ScalarConstructorExpression>(
                       create<ast::SintLiteral>(&i32, 2))),
-              create<ast::IdentifierExpression>("bar")),
-          create<ast::IdentifierExpression>("baz")),
-      create<ast::IdentifierExpression>("yx"));
+              create<ast::IdentifierExpression>(mod->RegisterSymbol("bar"),
+                                                "bar")),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("baz"), "baz")),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("yx"), "yx"));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -906,9 +928,10 @@
                     create<ast::TypeConstructorExpression>(&arr, ary_params),
                     ast::VariableDecorationList{});
 
-  ast::ArrayAccessorExpression expr(create<ast::IdentifierExpression>("pos"),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 1)));
+  ast::ArrayAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::UintLiteral>(&u32, 1)));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error();
@@ -963,9 +986,10 @@
       create<ast::TypeConstructorExpression>(&vec, std::move(vec_params)),
       ast::VariableDecorationList{});
 
-  ast::ArrayAccessorExpression expr(create<ast::IdentifierExpression>("pos"),
-                                    create<ast::ScalarConstructorExpression>(
-                                        create<ast::UintLiteral>(&u32, 1)));
+  ast::ArrayAccessorExpression expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::UintLiteral>(&u32, 1)));
 
   td.RegisterVariableForTesting(&var);
   ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error();

diff --git a/src/writer/spirv/builder_assign_test.cc b/src/writer/spirv/builder_assign_test.cc
index cee9950..2285beb 100644
--- a/src/writer/spirv/builder_assign_test.cc
+++ b/src/writer/spirv/builder_assign_test.cc

@@ -47,7 +47,8 @@
   ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &f32, false,
                   nullptr, ast::VariableDecorationList{});
 
-  auto* ident = create<ast::IdentifierExpression>("var");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
   auto* val = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f));
 
@@ -82,7 +83,8 @@
   ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec, false,
                   nullptr, ast::VariableDecorationList{});
 
-  auto* ident = create<ast::IdentifierExpression>("var");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
   ast::ExpressionList vals;
   auto* val = create<ast::TypeConstructorExpression>(&vec, vals);
 
@@ -133,8 +135,9 @@
   ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
                   nullptr, ast::VariableDecorationList{});
 
-  ast::AssignmentStatement assign(create<ast::IdentifierExpression>("var"),
-                                  init);
+  ast::AssignmentStatement assign(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
+      init);
 
   td.RegisterVariableForTesting(&v);
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
@@ -182,8 +185,9 @@
   ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
                   nullptr, ast::VariableDecorationList{});
 
-  ast::AssignmentStatement assign(create<ast::IdentifierExpression>("var"),
-                                  init);
+  ast::AssignmentStatement assign(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
+      init);
 
   td.RegisterVariableForTesting(&v);
   ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
@@ -231,8 +235,8 @@
                   false, nullptr, ast::VariableDecorationList{});
 
   auto* ident = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("ident"),
-      create<ast::IdentifierExpression>("b"));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"));
 
   auto* val = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 4.0f));
@@ -273,7 +277,8 @@
   ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
                   nullptr, ast::VariableDecorationList{});
 
-  auto* ident = create<ast::IdentifierExpression>("var");
+  auto* ident =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
 
   ast::ExpressionList vals;
   vals.push_back(create<ast::ScalarConstructorExpression>(
@@ -322,8 +327,8 @@
                   nullptr, ast::VariableDecorationList{});
 
   auto* ident = create<ast::MemberAccessorExpression>(
-      create<ast::IdentifierExpression>("var"),
-      create<ast::IdentifierExpression>("y"));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y"));
   auto* val = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.0f));
 
@@ -368,7 +373,7 @@
                   nullptr, ast::VariableDecorationList{});
 
   auto* ident = create<ast::ArrayAccessorExpression>(
-      create<ast::IdentifierExpression>("var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
       create<ast::ScalarConstructorExpression>(
           create<ast::SintLiteral>(&i32, 1)));
   auto* val = create<ast::ScalarConstructorExpression>(

diff --git a/src/writer/spirv/builder_binary_expression_test.cc b/src/writer/spirv/builder_binary_expression_test.cc
index 60d9828..880834e 100644
--- a/src/writer/spirv/builder_binary_expression_test.cc
+++ b/src/writer/spirv/builder_binary_expression_test.cc

@@ -124,8 +124,10 @@
   ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &i32,
                     false, nullptr, ast::VariableDecorationList{});
 
-  auto* lhs = create<ast::IdentifierExpression>("param");
-  auto* rhs = create<ast::IdentifierExpression>("param");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param");
 
   ast::BinaryExpression expr(param.op, lhs, rhs);
 
@@ -642,7 +644,8 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
   auto* rhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f));
 
@@ -683,7 +686,8 @@
                             ast::VariableDecorationList{});  // decorations
   auto* lhs = create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f));
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -721,7 +725,8 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
 
   ast::ExpressionList vals;
   vals.push_back(create<ast::ScalarConstructorExpression>(
@@ -779,7 +784,8 @@
       create<ast::FloatLiteral>(&f32, 1.f)));
   auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
 
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -818,8 +824,10 @@
                             false,                           // is_const
                             nullptr,                         // constructor
                             ast::VariableDecorationList{});  // decorations
-  auto* lhs = create<ast::IdentifierExpression>("mat");
-  auto* rhs = create<ast::IdentifierExpression>("mat");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
 
   td.RegisterVariableForTesting(var);
 
@@ -911,8 +919,8 @@
           create<ast::BoolLiteral>(&bool_type, false)),  // constructor
       ast::VariableDecorationList{});                    // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
-  auto* rhs = create<ast::IdentifierExpression>("b");
+  auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
+  auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");
 
   td.RegisterVariableForTesting(a_var);
   td.RegisterVariableForTesting(b_var);
@@ -1107,8 +1115,8 @@
           create<ast::BoolLiteral>(&bool_type, false)),  // constructor
       ast::VariableDecorationList{});                    // decorations
 
-  auto* lhs = create<ast::IdentifierExpression>("a");
-  auto* rhs = create<ast::IdentifierExpression>("b");
+  auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
+  auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");
 
   td.RegisterVariableForTesting(a_var);
   td.RegisterVariableForTesting(b_var);

diff --git a/src/writer/spirv/builder_block_test.cc b/src/writer/spirv/builder_block_test.cc
index 9d82125..838a084 100644
--- a/src/writer/spirv/builder_block_test.cc
+++ b/src/writer/spirv/builder_block_test.cc

@@ -50,7 +50,7 @@
                             nullptr,                           // constructor
                             ast::VariableDecorationList{})));  // decorations
   outer.append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 1.0f))));
 
@@ -64,13 +64,13 @@
                             nullptr,                           // constructor
                             ast::VariableDecorationList{})));  // decorations
   inner->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 2.0f))));
 
   outer.append(inner);
   outer.append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("var"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
       create<ast::ScalarConstructorExpression>(
           create<ast::FloatLiteral>(&f32, 3.0f))));
 

diff --git a/src/writer/spirv/builder_call_test.cc b/src/writer/spirv/builder_call_test.cc
index a4585a5..8cc1ba2 100644
--- a/src/writer/spirv/builder_call_test.cc
+++ b/src/writer/spirv/builder_call_test.cc

@@ -1,3 +1,4 @@
+
 // Copyright 2020 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -62,9 +63,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::BinaryExpression>(
-                    ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("a"),
-                    create<ast::IdentifierExpression>("b"))));
+      Source{},
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kAdd,
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"))));
   ast::Function a_func(Source{}, mod->RegisterSymbol("a_func"), "a_func",
                        func_params, &f32, body, ast::FunctionDecorationList{});
 
@@ -78,7 +81,8 @@
   call_params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  ast::CallExpression expr(create<ast::IdentifierExpression>("a_func"),
+  ast::CallExpression expr(create<ast::IdentifierExpression>(
+                               mod->RegisterSymbol("a_func"), "a_func"),
                            call_params);
 
   ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
@@ -139,9 +143,11 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::BinaryExpression>(
-                    ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("a"),
-                    create<ast::IdentifierExpression>("b"))));
+      Source{},
+      create<ast::BinaryExpression>(
+          ast::BinaryOp::kAdd,
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
+          create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"))));
 
   ast::Function a_func(Source{}, mod->RegisterSymbol("a_func"), "a_func",
                        func_params, &void_type, body,
@@ -157,8 +163,10 @@
   call_params.push_back(create<ast::ScalarConstructorExpression>(
       create<ast::FloatLiteral>(&f32, 1.f)));
 
-  ast::CallStatement expr(create<ast::CallExpression>(
-      create<ast::IdentifierExpression>("a_func"), call_params));
+  ast::CallStatement expr(
+      create<ast::CallExpression>(create<ast::IdentifierExpression>(
+                                      mod->RegisterSymbol("a_func"), "a_func"),
+                                  call_params));
 
   ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
   ASSERT_TRUE(td.DetermineFunction(&a_func)) << td.error();

diff --git a/src/writer/spirv/builder_function_decoration_test.cc b/src/writer/spirv/builder_function_decoration_test.cc
index dfab021..f349f2e 100644
--- a/src/writer/spirv/builder_function_decoration_test.cc
+++ b/src/writer/spirv/builder_function_decoration_test.cc

@@ -165,15 +165,20 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("my_out"),
-      create<ast::IdentifierExpression>("my_in")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_out"),
+                                        "my_out"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_in"),
+                                        "my_in")));
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("my_wg"),
-      create<ast::IdentifierExpression>("my_wg")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_wg"), "my_wg"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_wg"),
+                                        "my_wg")));
   // Add duplicate usages so we show they don't get output multiple times.
   body->append(create<ast::AssignmentStatement>(
-      create<ast::IdentifierExpression>("my_out"),
-      create<ast::IdentifierExpression>("my_in")));
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_out"),
+                                        "my_out"),
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("my_in"),
+                                        "my_in")));
 
   ast::Function func(
       Source{}, mod->RegisterSymbol("main"), "main", {}, &void_type, body,

diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc
index 983a3b2..db78c03 100644
--- a/src/writer/spirv/builder_function_test.cc
+++ b/src/writer/spirv/builder_function_test.cc

@@ -98,7 +98,8 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("a")));
+      Source{},
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a")));
   ASSERT_TRUE(td.DetermineResultType(body)) << td.error();
 
   ast::Function func(Source{}, mod->RegisterSymbol("a_func"), "a_func", {},
@@ -167,7 +168,8 @@
 
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::ReturnStatement>(
-      Source{}, create<ast::IdentifierExpression>("a")));
+      Source{},
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a")));
   ast::Function func(Source{}, mod->RegisterSymbol("a_func"), "a_func", params,
                      &f32, body, ast::FunctionDecorationList{});
 
@@ -299,8 +301,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod->RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod->RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();
@@ -326,8 +330,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod->RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod->RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();

diff --git a/src/writer/spirv/builder_function_variable_test.cc b/src/writer/spirv/builder_function_variable_test.cc
index 31b030a..fcdfeb3 100644
--- a/src/writer/spirv/builder_function_variable_test.cc
+++ b/src/writer/spirv/builder_function_variable_test.cc

@@ -168,9 +168,10 @@
                   init, ast::VariableDecorationList{});
   td.RegisterVariableForTesting(&v);
 
-  ast::Variable v2(Source{}, "v2", ast::StorageClass::kFunction, &f32, false,
-                   create<ast::IdentifierExpression>("v"),
-                   ast::VariableDecorationList{});
+  ast::Variable v2(
+      Source{}, "v2", ast::StorageClass::kFunction, &f32, false,
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      ast::VariableDecorationList{});
   td.RegisterVariableForTesting(&v2);
 
   ASSERT_TRUE(td.DetermineResultType(v2.constructor())) << td.error();
@@ -214,9 +215,10 @@
                   init, ast::VariableDecorationList{});
   td.RegisterVariableForTesting(&v);
 
-  ast::Variable v2(Source{}, "v2", ast::StorageClass::kFunction, &f32, true,
-                   create<ast::IdentifierExpression>("v"),
-                   ast::VariableDecorationList{});
+  ast::Variable v2(
+      Source{}, "v2", ast::StorageClass::kFunction, &f32, true,
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      ast::VariableDecorationList{});
   td.RegisterVariableForTesting(&v2);
 
   ASSERT_TRUE(td.DetermineResultType(v2.constructor())) << td.error();

diff --git a/src/writer/spirv/builder_ident_expression_test.cc b/src/writer/spirv/builder_ident_expression_test.cc
index 18f25f3..d678c76 100644
--- a/src/writer/spirv/builder_ident_expression_test.cc
+++ b/src/writer/spirv/builder_ident_expression_test.cc

@@ -68,7 +68,7 @@
 %5 = OpConstantComposite %1 %3 %3 %4
 )");
 
-  ast::IdentifierExpression expr("var");
+  ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
   ASSERT_TRUE(td.DetermineResultType(&expr));
 
   EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
@@ -91,7 +91,7 @@
 %1 = OpVariable %2 Output %4
 )");
 
-  ast::IdentifierExpression expr("var");
+  ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
   ASSERT_TRUE(td.DetermineResultType(&expr));
   EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
 }
@@ -126,7 +126,7 @@
 %5 = OpConstantComposite %1 %3 %3 %4
 )");
 
-  ast::IdentifierExpression expr("var");
+  ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
   ASSERT_TRUE(td.DetermineResultType(&expr));
   EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
 }
@@ -152,7 +152,7 @@
             R"(%1 = OpVariable %2 Function %4
 )");
 
-  ast::IdentifierExpression expr("var");
+  ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
   ASSERT_TRUE(td.DetermineResultType(&expr));
   EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
 }
@@ -165,8 +165,10 @@
 
   td.RegisterVariableForTesting(&var);
 
-  auto* lhs = create<ast::IdentifierExpression>("var");
-  auto* rhs = create<ast::IdentifierExpression>("var");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
 
   ast::BinaryExpression expr(ast::BinaryOp::kAdd, lhs, rhs);
 
@@ -198,8 +200,10 @@
 
   td.RegisterVariableForTesting(&var);
 
-  auto* lhs = create<ast::IdentifierExpression>("var");
-  auto* rhs = create<ast::IdentifierExpression>("var");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
 
   ast::BinaryExpression expr(ast::BinaryOp::kAdd, lhs, rhs);
 

diff --git a/src/writer/spirv/builder_if_test.cc b/src/writer/spirv/builder_if_test.cc
index c484be6..b85dff9 100644
--- a/src/writer/spirv/builder_if_test.cc
+++ b/src/writer/spirv/builder_if_test.cc

@@ -85,10 +85,10 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* cond = create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, true));
@@ -139,16 +139,16 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* else_body = create<ast::BlockStatement>();
-  else_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  else_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
 
   auto* cond = create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, true));
@@ -205,16 +205,16 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* else_body = create<ast::BlockStatement>();
-  else_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  else_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
 
   auto* else_cond = create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, true));
@@ -283,25 +283,25 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
   auto* elseif_1_body = create<ast::BlockStatement>();
-  elseif_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  elseif_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
   auto* elseif_2_body = create<ast::BlockStatement>();
-  elseif_2_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 4))));
+  elseif_2_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 4))));
   auto* else_body = create<ast::BlockStatement>();
-  else_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 5))));
+  else_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 5))));
 
   auto* elseif_1_cond = create<ast::ScalarConstructorExpression>(
       create<ast::BoolLiteral>(&bool_type, true));
@@ -643,9 +643,10 @@
                             ast::VariableDecorationList{});  // decorations
   td.RegisterVariableForTesting(var);
 
-  ast::IfStatement expr(Source{}, create<ast::IdentifierExpression>("a"),
-                        create<ast::BlockStatement>(),
-                        ast::ElseStatementList{});
+  ast::IfStatement expr(
+      Source{},
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
+      create<ast::BlockStatement>(), ast::ElseStatementList{});
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 

diff --git a/src/writer/spirv/builder_loop_test.cc b/src/writer/spirv/builder_loop_test.cc
index 6a5776c..5bc1327 100644
--- a/src/writer/spirv/builder_loop_test.cc
+++ b/src/writer/spirv/builder_loop_test.cc

@@ -75,10 +75,10 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   ast::LoopStatement expr(body, create<ast::BlockStatement>());
 
@@ -128,16 +128,16 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* body = create<ast::BlockStatement>();
-  body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* continuing = create<ast::BlockStatement>();
-  continuing->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  continuing->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
   ast::LoopStatement expr(body, continuing);
 
   td.RegisterVariableForTesting(var);

diff --git a/src/writer/spirv/builder_return_test.cc b/src/writer/spirv/builder_return_test.cc
index 973efd6..a219649 100644
--- a/src/writer/spirv/builder_return_test.cc
+++ b/src/writer/spirv/builder_return_test.cc

@@ -84,8 +84,9 @@
   ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &f32,
                     false, nullptr, ast::VariableDecorationList{});
 
-  ast::ReturnStatement ret(Source{},
-                           create<ast::IdentifierExpression>("param"));
+  ast::ReturnStatement ret(
+      Source{},
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param"));
 
   td.RegisterVariableForTesting(&var);
   EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();

diff --git a/src/writer/spirv/builder_switch_test.cc b/src/writer/spirv/builder_switch_test.cc
index b57cee9..c8d7be0 100644
--- a/src/writer/spirv/builder_switch_test.cc
+++ b/src/writer/spirv/builder_switch_test.cc

@@ -94,16 +94,16 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* case_1_body = create<ast::BlockStatement>();
-  case_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  case_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
 
   auto* case_2_body = create<ast::BlockStatement>();
-  case_2_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  case_2_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   ast::CaseSelectorList selector_1;
   selector_1.push_back(create<ast::SintLiteral>(&i32, 1));
@@ -115,7 +115,8 @@
   cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
   cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);
@@ -187,15 +188,16 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* default_body = create<ast::BlockStatement>();
-  default_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  default_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
 
   ast::CaseStatementList cases;
   cases.push_back(create<ast::CaseStatement>(default_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);
@@ -265,22 +267,22 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* case_1_body = create<ast::BlockStatement>();
-  case_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  case_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
 
   auto* case_2_body = create<ast::BlockStatement>();
-  case_2_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  case_2_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* default_body = create<ast::BlockStatement>();
-  default_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  default_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
 
   ast::CaseSelectorList selector_1;
   selector_1.push_back(create<ast::SintLiteral>(&i32, 1));
@@ -294,7 +296,8 @@
   cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
   cases.push_back(create<ast::CaseStatement>(default_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);
@@ -373,23 +376,23 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* case_1_body = create<ast::BlockStatement>();
-  case_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  case_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
   case_1_body->append(create<ast::FallthroughStatement>());
 
   auto* case_2_body = create<ast::BlockStatement>();
-  case_2_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 2))));
+  case_2_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 2))));
 
   auto* default_body = create<ast::BlockStatement>();
-  default_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 3))));
+  default_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 3))));
 
   ast::CaseSelectorList selector_1;
   selector_1.push_back(create<ast::SintLiteral>(&i32, 1));
@@ -402,7 +405,8 @@
   cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
   cases.push_back(create<ast::CaseStatement>(default_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);
@@ -477,10 +481,10 @@
                             ast::VariableDecorationList{});  // decorations
 
   auto* case_1_body = create<ast::BlockStatement>();
-  case_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  case_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
   case_1_body->append(create<ast::FallthroughStatement>());
 
   ast::CaseSelectorList selector_1;
@@ -489,7 +493,8 @@
   ast::CaseStatementList cases;
   cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);
@@ -546,10 +551,10 @@
                                    create<ast::BoolLiteral>(&bool_type, true)),
                                if_body, ast::ElseStatementList{}));
 
-  case_1_body->append(
-      create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
-                                       create<ast::ScalarConstructorExpression>(
-                                           create<ast::SintLiteral>(&i32, 1))));
+  case_1_body->append(create<ast::AssignmentStatement>(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
+      create<ast::ScalarConstructorExpression>(
+          create<ast::SintLiteral>(&i32, 1))));
 
   ast::CaseSelectorList selector_1;
   selector_1.push_back(create<ast::SintLiteral>(&i32, 1));
@@ -557,7 +562,8 @@
   ast::CaseStatementList cases;
   cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
 
-  ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
+  ast::SwitchStatement expr(
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
 
   td.RegisterVariableForTesting(v);
   td.RegisterVariableForTesting(a);

diff --git a/src/writer/spirv/builder_unary_op_expression_test.cc b/src/writer/spirv/builder_unary_op_expression_test.cc
index ef173a5..2579b87 100644
--- a/src/writer/spirv/builder_unary_op_expression_test.cc
+++ b/src/writer/spirv/builder_unary_op_expression_test.cc

@@ -101,8 +101,9 @@
   ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &vec,
                     false, nullptr, ast::VariableDecorationList{});
 
-  ast::UnaryOpExpression expr(ast::UnaryOp::kNegation,
-                              create<ast::IdentifierExpression>("param"));
+  ast::UnaryOpExpression expr(
+      ast::UnaryOp::kNegation,
+      create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param"));
 
   td.RegisterVariableForTesting(&var);
   EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();

diff --git a/src/writer/wgsl/generator_impl_array_accessor_test.cc b/src/writer/wgsl/generator_impl_array_accessor_test.cc
index 8678557..034051d 100644
--- a/src/writer/wgsl/generator_impl_array_accessor_test.cc
+++ b/src/writer/wgsl/generator_impl_array_accessor_test.cc

@@ -34,7 +34,8 @@
   ast::type::I32 i32;
   auto* lit = create<ast::SintLiteral>(&i32, 5);
   auto* idx = create<ast::ScalarConstructorExpression>(lit);
-  auto* ary = create<ast::IdentifierExpression>("ary");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 
@@ -43,8 +44,10 @@
 }
 
 TEST_F(WgslGeneratorImplTest, EmitArrayAccessor) {
-  auto* ary = create<ast::IdentifierExpression>("ary");
-  auto* idx = create<ast::IdentifierExpression>("idx");
+  auto* ary =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
+  auto* idx =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
 
   ast::ArrayAccessorExpression expr(ary, idx);
 

diff --git a/src/writer/wgsl/generator_impl_assign_test.cc b/src/writer/wgsl/generator_impl_assign_test.cc
index 9679c6b..891eeed 100644
--- a/src/writer/wgsl/generator_impl_assign_test.cc
+++ b/src/writer/wgsl/generator_impl_assign_test.cc

@@ -29,8 +29,10 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Assign) {
-  auto* lhs = create<ast::IdentifierExpression>("lhs");
-  auto* rhs = create<ast::IdentifierExpression>("rhs");
+  auto* lhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
+  auto* rhs =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
   ast::AssignmentStatement assign(lhs, rhs);
 
   gen.increment_indent();

diff --git a/src/writer/wgsl/generator_impl_binary_test.cc b/src/writer/wgsl/generator_impl_binary_test.cc
index 825668f..0ad8c07 100644
--- a/src/writer/wgsl/generator_impl_binary_test.cc
+++ b/src/writer/wgsl/generator_impl_binary_test.cc

@@ -37,8 +37,10 @@
 TEST_P(WgslBinaryTest, Emit) {
   auto params = GetParam();
 
-  auto* left = create<ast::IdentifierExpression>("left");
-  auto* right = create<ast::IdentifierExpression>("right");
+  auto* left =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
+  auto* right =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
 
   ast::BinaryExpression expr(params.op, left, right);
 

diff --git a/src/writer/wgsl/generator_impl_bitcast_test.cc b/src/writer/wgsl/generator_impl_bitcast_test.cc
index 2b9d5e8..bf1cc6b 100644
--- a/src/writer/wgsl/generator_impl_bitcast_test.cc
+++ b/src/writer/wgsl/generator_impl_bitcast_test.cc

@@ -30,7 +30,7 @@
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Bitcast) {
   ast::type::F32 f32;
-  auto* id = create<ast::IdentifierExpression>("id");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
   ast::BitcastExpression bitcast(&f32, id);
 
   ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();

diff --git a/src/writer/wgsl/generator_impl_call_test.cc b/src/writer/wgsl/generator_impl_call_test.cc
index 8afc062..77cf83c 100644
--- a/src/writer/wgsl/generator_impl_call_test.cc
+++ b/src/writer/wgsl/generator_impl_call_test.cc

@@ -29,7 +29,8 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::CallExpression call(id, {});
 
   ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
@@ -37,10 +38,13 @@
 }
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithParams) {
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
   ast::CallExpression call(id, params);
 
   ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
@@ -48,10 +52,13 @@
 }
 
 TEST_F(WgslGeneratorImplTest, EmitStatement_Call) {
-  auto* id = create<ast::IdentifierExpression>("my_func");
+  auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
+                                               "my_func");
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(create<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param1"), "param1"));
+  params.push_back(create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("param2"), "param2"));
 
   ast::CallStatement call(create<ast::CallExpression>(id, params));
 

diff --git a/src/writer/wgsl/generator_impl_cast_test.cc b/src/writer/wgsl/generator_impl_cast_test.cc
index 6b0e933..a0e9f1b 100644
--- a/src/writer/wgsl/generator_impl_cast_test.cc
+++ b/src/writer/wgsl/generator_impl_cast_test.cc

@@ -32,7 +32,8 @@
   ast::type::F32 f32;
 
   ast::ExpressionList params;
-  params.push_back(create<ast::IdentifierExpression>("id"));
+  params.push_back(
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
 
   ast::TypeConstructorExpression cast(&f32, params);
 

diff --git a/src/writer/wgsl/generator_impl_function_test.cc b/src/writer/wgsl/generator_impl_function_test.cc
index 573b391..2f44fa9 100644
--- a/src/writer/wgsl/generator_impl_function_test.cc
+++ b/src/writer/wgsl/generator_impl_function_test.cc

@@ -230,8 +230,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();
@@ -257,8 +259,10 @@
         &f32,                          // type
         false,                         // is_const
         create<ast::MemberAccessorExpression>(
-            create<ast::IdentifierExpression>("data"),
-            create<ast::IdentifierExpression>("d")),  // constructor
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
+                                              "data"),
+            create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
+                                              "d")),  // constructor
         ast::VariableDecorationList{});               // decorations
 
     auto* body = create<ast::BlockStatement>();

diff --git a/src/writer/wgsl/generator_impl_identifier_test.cc b/src/writer/wgsl/generator_impl_identifier_test.cc
index d0f6b31..d01e3ea 100644
--- a/src/writer/wgsl/generator_impl_identifier_test.cc
+++ b/src/writer/wgsl/generator_impl_identifier_test.cc

@@ -24,7 +24,7 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) {
-  ast::IdentifierExpression i("glsl");
+  ast::IdentifierExpression i(mod.RegisterSymbol("glsl"), "glsl");
 
   ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
   EXPECT_EQ(gen.result(), "glsl");

diff --git a/src/writer/wgsl/generator_impl_if_test.cc b/src/writer/wgsl/generator_impl_if_test.cc
index b2e2205..29051a9 100644
--- a/src/writer/wgsl/generator_impl_if_test.cc
+++ b/src/writer/wgsl/generator_impl_if_test.cc

@@ -28,7 +28,8 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_If) {
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::DiscardStatement>());
 
@@ -44,11 +45,13 @@
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::DiscardStatement>());
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::DiscardStatement>());
 
@@ -70,7 +73,8 @@
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::DiscardStatement>());
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::DiscardStatement>());
 
@@ -89,7 +93,8 @@
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_IfWithMultiple) {
-  auto* else_cond = create<ast::IdentifierExpression>("else_cond");
+  auto* else_cond = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("else_cond"), "else_cond");
 
   auto* else_body = create<ast::BlockStatement>();
   else_body->append(create<ast::DiscardStatement>());
@@ -97,7 +102,8 @@
   auto* else_body_2 = create<ast::BlockStatement>();
   else_body_2->append(create<ast::DiscardStatement>());
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   auto* body = create<ast::BlockStatement>();
   body->append(create<ast::DiscardStatement>());
 

diff --git a/src/writer/wgsl/generator_impl_member_accessor_test.cc b/src/writer/wgsl/generator_impl_member_accessor_test.cc
index 8ff995e..fd5be5a 100644
--- a/src/writer/wgsl/generator_impl_member_accessor_test.cc
+++ b/src/writer/wgsl/generator_impl_member_accessor_test.cc

@@ -28,8 +28,10 @@
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) {
-  auto* str = create<ast::IdentifierExpression>("str");
-  auto* mem = create<ast::IdentifierExpression>("mem");
+  auto* str =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("str"), "str");
+  auto* mem =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("mem"), "mem");
 
   ast::MemberAccessorExpression expr(str, mem);
 

diff --git a/src/writer/wgsl/generator_impl_return_test.cc b/src/writer/wgsl/generator_impl_return_test.cc
index 12703a7..0cad4a0 100644
--- a/src/writer/wgsl/generator_impl_return_test.cc
+++ b/src/writer/wgsl/generator_impl_return_test.cc

@@ -38,7 +38,8 @@
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_ReturnWithValue) {
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::ReturnStatement r(Source{}, expr);
 
   gen.increment_indent();

diff --git a/src/writer/wgsl/generator_impl_switch_test.cc b/src/writer/wgsl/generator_impl_switch_test.cc
index 29f22cc..732998f 100644
--- a/src/writer/wgsl/generator_impl_switch_test.cc
+++ b/src/writer/wgsl/generator_impl_switch_test.cc

@@ -49,7 +49,8 @@
   body.push_back(case_stmt);
   body.push_back(def);
 
-  auto* cond = create<ast::IdentifierExpression>("cond");
+  auto* cond =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
   ast::SwitchStatement s(cond, body);
 
   gen.increment_indent();

diff --git a/src/writer/wgsl/generator_impl_unary_op_test.cc b/src/writer/wgsl/generator_impl_unary_op_test.cc
index 518be49..dbac9fc 100644
--- a/src/writer/wgsl/generator_impl_unary_op_test.cc
+++ b/src/writer/wgsl/generator_impl_unary_op_test.cc

@@ -38,7 +38,8 @@
 TEST_P(WgslUnaryOpTest, Emit) {
   auto params = GetParam();
 
-  auto* expr = create<ast::IdentifierExpression>("expr");
+  auto* expr =
+      create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
   ast::UnaryOpExpression op(params.op, expr);
 
   ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();

diff --git a/src/writer/wgsl/generator_impl_variable_test.cc b/src/writer/wgsl/generator_impl_variable_test.cc
index 6fcc325..39cffac 100644
--- a/src/writer/wgsl/generator_impl_variable_test.cc
+++ b/src/writer/wgsl/generator_impl_variable_test.cc

@@ -87,7 +87,8 @@
 }
 
 TEST_F(WgslGeneratorImplTest, EmitVariable_Constructor) {
-  auto* ident = create<ast::IdentifierExpression>("initializer");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("initializer"), "initializer");
 
   ast::type::F32 f32;
   ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, false, ident,
@@ -99,7 +100,8 @@
 }
 
 TEST_F(WgslGeneratorImplTest, EmitVariable_Const) {
-  auto* ident = create<ast::IdentifierExpression>("initializer");
+  auto* ident = create<ast::IdentifierExpression>(
+      mod.RegisterSymbol("initializer"), "initializer");
 
   ast::type::F32 f32;
   ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, true, ident,