reland-fix: Remove name shadowing of Register

We have that for the following program:

```
struct Foo {
  int X = 0;
};

struct Bar {
  struct Foo Foo;
}
```

will generate the following when compiled with gcc/g++:
`error: declaration of ‘Foo Bar::Foo’ changes meaning of ‘Foo’ [-fpermissive]`

but no error is generated when compiling with clang/clang++.

This commit removes the name shadowing of Register to prevent compilation
errors when building llvm with gcc/g++.

Author: Finn Plummer

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -78,7 +78,7 @@ class RootSignatureParser {
   /// order and only exactly once. `ParsedClauseParams` denotes the current
   /// state of parsed params
   struct ParsedClauseParams {
-    std::optional<llvm::hlsl::rootsig::Register> Register;
+    std::optional<llvm::hlsl::rootsig::Register> Reg;
     std::optional<uint32_t> Space;
   };
   std::optional<ParsedClauseParams>

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -123,13 +123,13 @@ bool RootSignatureParser::parseDescriptorTableClause() {
     return true;
 
   // Check mandatory parameters were provided
-  if (!Params->Register.has_value()) {
+  if (!Params->Reg.has_value()) {
     getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_missing_param)
         << ExpectedReg;
     return true;
   }
 
-  Clause.Register = Params->Register.value();
+  Clause.Reg = Params->Reg.value();
 
   // Fill in optional values
   if (Params->Space.has_value())
@@ -156,15 +156,15 @@ RootSignatureParser::parseDescriptorTableClauseParams(TokenKind RegType) {
   do {
     // ( `b` | `t` | `u` | `s`) POS_INT
     if (tryConsumeExpectedToken(RegType)) {
-      if (Params.Register.has_value()) {
+      if (Params.Reg.has_value()) {
         getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_repeat_param)
             << CurToken.TokKind;
         return std::nullopt;
       }
       auto Reg = parseRegister();
       if (!Reg.has_value())
         return std::nullopt;
-      Params.Register = Reg;
+      Params.Reg = Reg;
     }
 
     // `space` `=` POS_INT
@@ -205,30 +205,30 @@ std::optional<Register> RootSignatureParser::parseRegister() {
           CurToken.TokKind == TokenKind::sReg) &&
          "Expects to only be invoked starting at given keyword");
 
-  Register Register;
+  Register Reg;
   switch (CurToken.TokKind) {
   default:
     llvm_unreachable("Switch for consumed token was not provided");
   case TokenKind::bReg:
-    Register.ViewType = RegisterType::BReg;
+    Reg.ViewType = RegisterType::BReg;
     break;
   case TokenKind::tReg:
-    Register.ViewType = RegisterType::TReg;
+    Reg.ViewType = RegisterType::TReg;
     break;
   case TokenKind::uReg:
-    Register.ViewType = RegisterType::UReg;
+    Reg.ViewType = RegisterType::UReg;
     break;
   case TokenKind::sReg:
-    Register.ViewType = RegisterType::SReg;
+    Reg.ViewType = RegisterType::SReg;
     break;
   }
 
   auto Number = handleUIntLiteral();
   if (!Number.has_value())
     return std::nullopt; // propogate NumericLiteralParser error
 
-  Register.Number = *Number;
-  return Register;
+  Reg.Number = *Number;
+  return Reg;
 }
 
 std::optional<uint32_t> RootSignatureParser::handleUIntLiteral() {

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -154,33 +154,33 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
   RootElement Elem = Elements[0];
   ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::CBuffer);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.ViewType,
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType,
             RegisterType::BReg);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.Number, 0u);
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 0u);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u);
 
   Elem = Elements[1];
   ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::SRV);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.ViewType,
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType,
             RegisterType::TReg);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.Number, 42u);
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 42u);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 3u);
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.ViewType,
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType,
             RegisterType::SReg);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.Number, 987u);
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 987u);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 2u);
 
   Elem = Elements[3];
   ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::UAV);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.ViewType,
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType,
             RegisterType::UReg);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Register.Number, 4294967294u);
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 4294967294u);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u);
 
   Elem = Elements[4];

llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h

@@ -39,7 +39,7 @@ struct DescriptorTable {
 using ClauseType = llvm::dxil::ResourceClass;
 struct DescriptorTableClause {
   ClauseType Type;
-  Register Register;
+  Register Reg;
   uint32_t Space = 0;
 };