Remove name fields

This CL removes the name fields from the various AST nodes now that the
symbols are used everywhere.

Change-Id: I73e8fa8958aa6e6f0159b12b63176b12c418f525
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/36762
Reviewed-by: Ben Clayton <bclayton@google.com>
Reviewed-by: Ryan Harrison <rharrison@chromium.org>

src/reader/spirv/function.cc

@@ -787,7 +787,7 @@ void FunctionEmitter::PushGuard(const std::string& guard_name,
   const auto& top = statements_stack_.back();
 
   auto* cond = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(guard_name), guard_name);
+      Source{}, ast_module_.RegisterSymbol(guard_name));
   auto* builder = AddStatementBuilder<IfStatementBuilder>(cond);
 
   PushNewStatementBlock(
@@ -862,8 +862,8 @@ bool FunctionEmitter::Emit() {
   auto* body = create<ast::BlockStatement>(Source{}, statements);
   ast_module_.AddFunction(
       create<ast::Function>(decl.source, ast_module_.RegisterSymbol(decl.name),
-                            decl.name, std::move(decl.params), decl.return_type,
-                            body, std::move(decl.decorations)));
+                            std::move(decl.params), decl.return_type, body,
+                            std::move(decl.decorations)));
 
   // Maintain the invariant by repopulating the one and only element.
   statements_stack_.clear();
@@ -2013,8 +2013,8 @@ TypedExpression FunctionEmitter::MakeExpression(uint32_t id) {
     auto name = namer_.Name(id);
     return TypedExpression{
         parser_impl_.ConvertType(def_use_mgr_->GetDef(id)->type_id()),
-        create<ast::IdentifierExpression>(
-            Source{}, ast_module_.RegisterSymbol(name), name)};
+        create<ast::IdentifierExpression>(Source{},
+                                          ast_module_.RegisterSymbol(name))};
   }
   if (singly_used_values_.count(id)) {
     auto expr = std::move(singly_used_values_[id]);
@@ -2034,10 +2034,9 @@ TypedExpression FunctionEmitter::MakeExpression(uint32_t id) {
     case SpvOpVariable: {
       // This occurs for module-scope variables.
       auto name = namer_.Name(inst->result_id());
-      return TypedExpression{
-          parser_impl_.ConvertType(inst->type_id()),
-          create<ast::IdentifierExpression>(
-              Source{}, ast_module_.RegisterSymbol(name), name)};
+      return TypedExpression{parser_impl_.ConvertType(inst->type_id()),
+                             create<ast::IdentifierExpression>(
+                                 Source{}, ast_module_.RegisterSymbol(name))};
     }
     default:
       break;
@@ -2269,7 +2268,6 @@ bool FunctionEmitter::EmitIfStart(const BlockInfo& block_info) {
     auto* guard_var =
         create<ast::Variable>(Source{},                                // source
                               ast_module_.RegisterSymbol(guard_name),  // symbol
-                              guard_name,                              // name
                               ast::StorageClass::kFunction,    // storage_class
                               parser_impl_.Bool(),             // type
                               false,                           // is_const
@@ -2676,7 +2674,7 @@ ast::Statement* FunctionEmitter::MakeBranchDetailed(
         return create<ast::AssignmentStatement>(
             Source{},
             create<ast::IdentifierExpression>(
-                Source{}, ast_module_.RegisterSymbol(flow_guard), flow_guard),
+                Source{}, ast_module_.RegisterSymbol(flow_guard)),
             MakeFalse(Source{}));
       }
 
@@ -2798,7 +2796,6 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info,
     auto* var = create<ast::Variable>(
         Source{},                                       // source
         ast_module_.RegisterSymbol(phi_var_name),       // symbol
-        phi_var_name,                                   // name
         ast::StorageClass::kFunction,                   // storage_class
         parser_impl_.ConvertType(def_inst->type_id()),  // type
         false,                                          // is_const
@@ -2837,7 +2834,7 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info,
       AddStatement(create<ast::AssignmentStatement>(
           Source{},
           create<ast::IdentifierExpression>(
-              Source{}, ast_module_.RegisterSymbol(var_name), var_name),
+              Source{}, ast_module_.RegisterSymbol(var_name)),
           expr.expr));
     }
   }
@@ -2874,8 +2871,8 @@ bool FunctionEmitter::EmitConstDefOrWriteToHoistedVar(
     // Emit an assignment of the expression to the hoisted variable.
     AddStatement(create<ast::AssignmentStatement>(
         Source{},
-        create<ast::IdentifierExpression>(
-            Source{}, ast_module_.RegisterSymbol(name), namer_.Name(result_id)),
+        create<ast::IdentifierExpression>(Source{},
+                                          ast_module_.RegisterSymbol(name)),
         ast_expr.expr));
     return true;
   }
@@ -3014,8 +3011,7 @@ bool FunctionEmitter::EmitStatement(const spvtools::opt::Instruction& inst) {
       TypedExpression expr{
           parser_impl_.ConvertType(inst.type_id()),
           create<ast::IdentifierExpression>(
-              Source{}, ast_module_.RegisterSymbol(def_info->phi_var),
-              def_info->phi_var)};
+              Source{}, ast_module_.RegisterSymbol(def_info->phi_var))};
       return EmitConstDefOrWriteToHoistedVar(inst, expr);
     }
 
@@ -3074,8 +3070,7 @@ TypedExpression FunctionEmitter::MaybeEmitCombinatorialValue(
             create<ast::CallExpression>(
                 Source{},
                 create<ast::IdentifierExpression>(
-                    Source{}, ast_module_.RegisterSymbol(unary_builtin_name),
-                    unary_builtin_name),
+                    Source{}, ast_module_.RegisterSymbol(unary_builtin_name)),
                 std::move(params))};
   }
 
@@ -3181,7 +3176,7 @@ TypedExpression FunctionEmitter::EmitGlslStd450ExtInst(
   }
 
   auto* func = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(name), name);
+      Source{}, ast_module_.RegisterSymbol(name));
   ast::ExpressionList operands;
   ast::type::Type* first_operand_type = nullptr;
   // All parameters to GLSL.std.450 extended instructions are IDs.
@@ -3207,20 +3202,20 @@ ast::IdentifierExpression* FunctionEmitter::Swizzle(uint32_t i) {
   }
   const char* names[] = {"x", "y", "z", "w"};
   return create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(names[i & 3]), names[i & 3]);
+      Source{}, ast_module_.RegisterSymbol(names[i & 3]));
 }
 
 ast::IdentifierExpression* FunctionEmitter::PrefixSwizzle(uint32_t n) {
   switch (n) {
     case 1:
-      return create<ast::IdentifierExpression>(
-          Source{}, ast_module_.RegisterSymbol("x"), "x");
+      return create<ast::IdentifierExpression>(Source{},
+                                               ast_module_.RegisterSymbol("x"));
     case 2:
       return create<ast::IdentifierExpression>(
-          Source{}, ast_module_.RegisterSymbol("xy"), "xy");
+          Source{}, ast_module_.RegisterSymbol("xy"));
     case 3:
       return create<ast::IdentifierExpression>(
-          Source{}, ast_module_.RegisterSymbol("xyz"), "xyz");
+          Source{}, ast_module_.RegisterSymbol("xyz"));
     default:
       break;
   }
@@ -3315,7 +3310,7 @@ TypedExpression FunctionEmitter::MakeAccessChain(
 
       auto name = namer_.Name(base_id);
       current_expr.expr = create<ast::IdentifierExpression>(
-          Source{}, ast_module_.RegisterSymbol(name), name);
+          Source{}, ast_module_.RegisterSymbol(name));
       current_expr.type = parser_impl_.ConvertType(ptr_ty_id);
     }
   }
@@ -3408,7 +3403,7 @@ TypedExpression FunctionEmitter::MakeAccessChain(
         auto name =
             namer_.GetMemberName(pointee_type_id, uint32_t(index_const_val));
         auto* member_access = create<ast::IdentifierExpression>(
-            Source{}, ast_module_.RegisterSymbol(name), name);
+            Source{}, ast_module_.RegisterSymbol(name));
 
         next_expr = create<ast::MemberAccessorExpression>(
             Source{}, current_expr.expr, member_access);
@@ -3529,7 +3524,7 @@ TypedExpression FunctionEmitter::MakeCompositeExtract(
         }
         auto name = namer_.GetMemberName(current_type_id, uint32_t(index_val));
         auto* member_access = create<ast::IdentifierExpression>(
-            Source{}, ast_module_.RegisterSymbol(name), name);
+            Source{}, ast_module_.RegisterSymbol(name));
 
         next_expr = create<ast::MemberAccessorExpression>(
             Source{}, current_expr.expr, member_access);
@@ -3933,7 +3928,7 @@ bool FunctionEmitter::EmitFunctionCall(const spvtools::opt::Instruction& inst) {
   // We ignore function attributes such as Inline, DontInline, Pure, Const.
   auto name = namer_.Name(inst.GetSingleWordInOperand(0));
   auto* function = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(name), name);
+      Source{}, ast_module_.RegisterSymbol(name));
 
   ast::ExpressionList params;
   for (uint32_t iarg = 1; iarg < inst.NumInOperands(); ++iarg) {
@@ -3962,7 +3957,7 @@ TypedExpression FunctionEmitter::MakeIntrinsicCall(
   ss << intrinsic;
   auto name = ss.str();
   auto* ident = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(name), name);
+      Source{}, ast_module_.RegisterSymbol(name));
   ident->set_intrinsic(intrinsic);
 
   ast::ExpressionList params;
@@ -4009,7 +4004,7 @@ TypedExpression FunctionEmitter::MakeSimpleSelect(
             create<ast::CallExpression>(
                 Source{},
                 create<ast::IdentifierExpression>(
-                    Source{}, ast_module_.RegisterSymbol("select"), "select"),
+                    Source{}, ast_module_.RegisterSymbol("select")),
                 std::move(params))};
   }
   return {};
@@ -4035,7 +4030,7 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
   }
   auto name = namer_.Name(image->result_id());
   params.push_back(create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(name), name));
+      Source{}, ast_module_.RegisterSymbol(name)));
 
   const auto opcode = inst.opcode();
   if (IsSampledImageAccess(opcode)) {
@@ -4048,7 +4043,7 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
     }
     auto param_name = namer_.Name(sampler->result_id());
     params.push_back(create<ast::IdentifierExpression>(
-        Source{}, ast_module_.RegisterSymbol(param_name), param_name));
+        Source{}, ast_module_.RegisterSymbol(param_name)));
   }
 
   ast::type::Pointer* texture_ptr_type =
@@ -4214,7 +4209,7 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
   }
 
   auto* ident = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(builtin_name), builtin_name);
+      Source{}, ast_module_.RegisterSymbol(builtin_name));
   auto* call_expr =
       create<ast::CallExpression>(Source{}, ident, std::move(params));
 
@@ -4556,14 +4551,14 @@ TypedExpression FunctionEmitter::MakeArrayLength(
   }
 
   auto* member_ident = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(field_name), field_name);
+      Source{}, ast_module_.RegisterSymbol(field_name));
   auto* member_access = create<ast::MemberAccessorExpression>(
       Source{}, MakeExpression(struct_ptr_id).expr, member_ident);
 
   // Generate the intrinsic function call.
   std::string call_ident_str = "arrayLength";
   auto* call_ident = create<ast::IdentifierExpression>(
-      Source{}, ast_module_.RegisterSymbol(call_ident_str), call_ident_str);
+      Source{}, ast_module_.RegisterSymbol(call_ident_str));
   call_ident->set_intrinsic(ast::Intrinsic::kArrayLength);
 
   ast::ExpressionList params{member_access};

src/reader/spirv/parser_impl.cc

@@ -948,8 +948,8 @@ ast::type::Type* ParserImpl::ConvertType(
     }
     const auto member_name = namer_.GetMemberName(type_id, member_index);
     auto* ast_struct_member = create<ast::StructMember>(
-        Source{}, ast_module_.RegisterSymbol(member_name), member_name,
-        ast_member_ty, std::move(ast_member_decorations));
+        Source{}, ast_module_.RegisterSymbol(member_name), ast_member_ty,
+        std::move(ast_member_decorations));
     ast_members.push_back(ast_struct_member);
   }
   if (is_per_vertex_struct) {
@@ -965,7 +965,7 @@ ast::type::Type* ParserImpl::ConvertType(
 
   auto name = namer_.GetName(type_id);
   auto* result = ast_module_.create<ast::type::Struct>(
-      ast_module_.RegisterSymbol(name), name, ast_struct);
+      ast_module_.RegisterSymbol(name), ast_struct);
   id_to_type_[type_id] = result;
   if (num_non_writable_members == members.size()) {
     read_only_struct_types_.insert(result);
@@ -1132,7 +1132,7 @@ void ParserImpl::MaybeGenerateAlias(uint32_t type_id,
   }
   const auto name = namer_.GetName(type_id);
   auto* ast_alias_type = ast_module_.create<ast::type::Alias>(
-      ast_module_.RegisterSymbol(name), name, ast_underlying_type);
+      ast_module_.RegisterSymbol(name), ast_underlying_type);
   // Record this new alias as the AST type for this SPIR-V ID.
   id_to_type_[type_id] = ast_alias_type;
   ast_module_.AddConstructedType(ast_alias_type);
@@ -1311,7 +1311,6 @@ ast::Variable* ParserImpl::MakeVariable(
   std::string name = namer_.Name(id);
   return create<ast::Variable>(Source{},                          // source
                                ast_module_.RegisterSymbol(name),  // symbol
-                               name,                              // name
                                sc,            // storage_class
                                type,          // type
                                is_const,      // is_const

src/reader/wgsl/parser_impl.cc

@@ -434,7 +434,6 @@ Maybe<ast::Variable*> ParserImpl::global_variable_decl(
 
   return create<ast::Variable>(decl->source,                        // source
                                module_.RegisterSymbol(decl->name),  // symbol
-                               decl->name,                          // name
                                decl->storage_class,          // storage_class
                                decl->type,                   // type
                                false,                        // is_const
@@ -463,7 +462,6 @@ Maybe<ast::Variable*> ParserImpl::global_constant_decl() {
 
   return create<ast::Variable>(decl->source,                        // source
                                module_.RegisterSymbol(decl->name),  // symbol
-                               decl->name,                          // name
                                ast::StorageClass::kNone,        // storage_class
                                decl->type,                      // type
                                true,                            // is_const
@@ -941,7 +939,7 @@ Maybe<ast::type::Type*> ParserImpl::type_alias() {
     return add_error(peek(), "invalid type alias");
 
   auto* alias = module_.create<ast::type::Alias>(
-      module_.RegisterSymbol(name.value), name.value, type.value);
+      module_.RegisterSymbol(name.value), type.value);
   register_constructed(name.value, alias);
 
   return alias;
@@ -1195,7 +1193,7 @@ Maybe<std::unique_ptr<ast::type::Struct>> ParserImpl::struct_decl(
     return Failure::kErrored;
 
   return std::make_unique<ast::type::Struct>(
-      module_.RegisterSymbol(name.value), name.value,
+      module_.RegisterSymbol(name.value),
       create<ast::Struct>(source, std::move(body.value),
                           std::move(struct_decos.value)));
 }
@@ -1249,9 +1247,9 @@ Expect<ast::StructMember*> ParserImpl::expect_struct_member(
   if (!expect("struct member", Token::Type::kSemicolon))
     return Failure::kErrored;
 
-  return create<ast::StructMember>(
-      decl->source, module_.RegisterSymbol(decl->name), decl->name, decl->type,
-      std::move(member_decos.value));
+  return create<ast::StructMember>(decl->source,
+                                   module_.RegisterSymbol(decl->name),
+                                   decl->type, std::move(member_decos.value));
 }
 
 // function_decl
@@ -1287,8 +1285,8 @@ Maybe<ast::Function*> ParserImpl::function_decl(ast::DecorationList& decos) {
     return Failure::kErrored;
 
   return create<ast::Function>(
-      header->source, module_.RegisterSymbol(header->name), header->name,
-      header->params, header->return_type, body.value, func_decos.value);
+      header->source, module_.RegisterSymbol(header->name), header->params,
+      header->return_type, body.value, func_decos.value);
 }
 
 // function_type_decl
@@ -1358,7 +1356,6 @@ Expect<ast::VariableList> ParserImpl::expect_param_list() {
     auto* var =
         create<ast::Variable>(decl->source,                        // source
                               module_.RegisterSymbol(decl->name),  // symbol
-                              decl->name,                          // name
                               ast::StorageClass::kNone,        // storage_class
                               decl->type,                      // type
                               true,                            // is_const
@@ -1630,7 +1627,6 @@ Maybe<ast::VariableDeclStatement*> ParserImpl::variable_stmt() {
     auto* var =
         create<ast::Variable>(decl->source,                        // source
                               module_.RegisterSymbol(decl->name),  // symbol
-                              decl->name,                          // name
                               ast::StorageClass::kNone,        // storage_class
                               decl->type,                      // type
                               true,                            // is_const
@@ -1660,7 +1656,6 @@ Maybe<ast::VariableDeclStatement*> ParserImpl::variable_stmt() {
   auto* var =
       create<ast::Variable>(decl->source,                        // source
                             module_.RegisterSymbol(decl->name),  // symbol
-                            decl->name,                          // name
                             decl->storage_class,             // storage_class
                             decl->type,                      // type
                             false,                           // is_const
@@ -2046,11 +2041,11 @@ Maybe<ast::CallStatement*> ParserImpl::func_call_stmt() {
     return Failure::kErrored;
 
   return create<ast::CallStatement>(
-      Source{}, create<ast::CallExpression>(
-                    source,
-                    create<ast::IdentifierExpression>(
-                        source, module_.RegisterSymbol(name), name),
-                    std::move(params)));
+      Source{},
+      create<ast::CallExpression>(source,
+                                  create<ast::IdentifierExpression>(
+                                      source, module_.RegisterSymbol(name)),
+                                  std::move(params)));
 }
 
 // break_stmt
@@ -2122,7 +2117,7 @@ Maybe<ast::Expression*> ParserImpl::primary_expression() {
 
   if (match(Token::Type::kIdentifier))
     return create<ast::IdentifierExpression>(
-        t.source(), module_.RegisterSymbol(t.to_str()), t.to_str());
+        t.source(), module_.RegisterSymbol(t.to_str()));
 
   auto type = type_decl();
   if (type.errored)
@@ -2198,7 +2193,7 @@ Maybe<ast::Expression*> ParserImpl::postfix_expr(ast::Expression* prefix) {
     return postfix_expr(create<ast::MemberAccessorExpression>(
         ident.source, prefix,
         create<ast::IdentifierExpression>(
-            ident.source, module_.RegisterSymbol(ident.value), ident.value)));
+            ident.source, module_.RegisterSymbol(ident.value))));
   }
 
   return prefix;

src/reader/wgsl/parser_impl_type_alias_test.cc

@@ -45,7 +45,7 @@ TEST_F(ParserImplTest, TypeDecl_ParsesType) {
 TEST_F(ParserImplTest, TypeDecl_ParsesStruct_Ident) {
   auto p = parser("type a = B");
 
-  ast::type::Struct str(p->get_module().RegisterSymbol("B"), "B", {});
+  ast::type::Struct str(p->get_module().RegisterSymbol("B"), {});
   p->register_constructed("B", &str);
 
   auto t = p->type_alias();

src/reader/wgsl/parser_impl_type_decl_test.cc

@@ -50,7 +50,7 @@ TEST_F(ParserImplTest, TypeDecl_Identifier) {
 
   auto* int_type = mod.create<ast::type::I32>();
   auto* alias_type =
-      mod.create<ast::type::Alias>(mod.RegisterSymbol("A"), "A", int_type);
+      mod.create<ast::type::Alias>(mod.RegisterSymbol("A"), int_type);
 
   p->register_constructed("A", alias_type);