add diag context when incorrectly specifiying a parameter

Author: inbelic

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1819,6 +1819,7 @@ def err_hlsl_unsupported_component : Error<"invalid component '%0' used; expecte
 def err_hlsl_packoffset_invalid_reg : Error<"invalid resource class specifier '%0' for packoffset, expected 'c'">;
 
 // HLSL Root Signature Parser Diagnostics
+def err_hlsl_expected_param : Error<"expected parameter in %1(%0)">;
 def err_hlsl_number_literal_overflow : Error<"integer literal is too large to be represented as a 32-bit %select{signed |}0 integer type">;
 def err_hlsl_rootsig_repeat_param : Error<"specified the same parameter '%0' multiple times">;
 def err_hlsl_rootsig_non_zero_flag : Error<"specified a non-zero integer as a flag">;

clang/include/clang/Lex/HLSLRootSignatureTokenKinds.def

@@ -68,6 +68,9 @@ PUNCTUATOR(equal,   '=')
 PUNCTUATOR(plus,    '+')
 PUNCTUATOR(minus,   '-')
 
+// RootSignature Keyword is only used for diagnostics:
+KEYWORD(RootSignature)
+
 // RootElement Keywords:
 KEYWORD(DescriptorTable)
 

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -71,8 +71,8 @@ class RootSignatureParser {
   /// Use NumericLiteralParser to convert CurToken.NumSpelling into a unsigned
   /// 32-bit integer
   bool HandleUIntLiteral(uint32_t &X);
-  bool ParseRegister(llvm::hlsl::rootsig::Register *Reg);
   bool ParseUInt(uint32_t *X);
+  bool ParseRegister(llvm::hlsl::rootsig::Register *Reg, TokenKind Context);
   bool
   ParseDescriptorRangeOffset(llvm::hlsl::rootsig::DescriptorRangeOffset *X);
 

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -61,7 +61,7 @@ bool RootSignatureParser::Parse() {
 }
 
 bool RootSignatureParser::ParseRootElement() {
-  if (ConsumeExpectedToken(TokenKind::kw_DescriptorTable))
+  if (ConsumeExpectedToken(TokenKind::kw_DescriptorTable, diag::err_hlsl_expected_param, /*Context=*/TokenKind::kw_RootSignature))
     return true;
 
   // Dispatch onto the correct parse method
@@ -117,7 +117,9 @@ bool RootSignatureParser::ParseDescriptorTable() {
 
 bool RootSignatureParser::ParseDescriptorTableClause() {
   if (ConsumeExpectedToken({TokenKind::kw_CBV, TokenKind::kw_SRV,
-                            TokenKind::kw_UAV, TokenKind::kw_Sampler}))
+                            TokenKind::kw_UAV, TokenKind::kw_Sampler},
+                           diag::err_hlsl_expected_param,
+                           /*Context=*/TokenKind::kw_DescriptorTable))
     return true;
 
   DescriptorTableClause Clause;
@@ -139,11 +141,14 @@ bool RootSignatureParser::ParseDescriptorTableClause() {
   }
   Clause.SetDefaultFlags();
 
+  // Store context of clause token type we are parsing
+  TokenKind Context = CurToken.Kind;
+
   if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after, CurToken.Kind))
     return true;
 
   // Consume mandatory Register paramater
-  if (ParseRegister(&Clause.Register))
+  if (ParseRegister(&Clause.Register, Context))
     return true;
 
   // Define optional paramaters
@@ -198,7 +203,7 @@ bool RootSignatureParser::ParseOptionalParams(
   llvm::SmallDenseSet<TokenKind> Seen;
 
   while (TryConsumeExpectedToken(TokenKind::pu_comma)) {
-    if (ConsumeExpectedToken(ParamKeywords))
+    if (ConsumeExpectedToken(ParamKeywords, diag::err_hlsl_expected_param, Context))
       return true;
 
     TokenKind ParamKind = CurToken.Kind;
@@ -239,9 +244,11 @@ bool RootSignatureParser::HandleUIntLiteral(uint32_t &X) {
   return false;
 }
 
-bool RootSignatureParser::ParseRegister(Register *Register) {
+bool RootSignatureParser::ParseRegister(Register *Register, TokenKind Context) {
   if (ConsumeExpectedToken(
-          {TokenKind::bReg, TokenKind::tReg, TokenKind::uReg, TokenKind::sReg}))
+          {TokenKind::bReg, TokenKind::tReg, TokenKind::uReg, TokenKind::sReg},
+          diag::err_hlsl_expected_param,
+          Context))
     return true;
 
   switch (CurToken.Kind) {
@@ -411,6 +418,7 @@ bool RootSignatureParser::ConsumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
     break;
   case diag::err_expected_either:
   case diag::err_expected_after:
+  case diag::err_hlsl_expected_param:
     DB << FormatTokenKinds(AnyExpected) << FormatTokenKinds({Context});
     break;
   default: break;

clang/unittests/Lex/LexHLSLRootSignatureTest.cpp

@@ -85,6 +85,8 @@ TEST_F(LexHLSLRootSignatureTest, ValidLexAllTokensTest) {
 
     (),|=+-
 
+    RootSignature
+
     DescriptorTable
 
     CBV SRV UAV Sampler

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -258,7 +258,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) {
   hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
 
   // Test correct diagnostic produced - invalid token
-  Consumer->SetExpected(diag::err_expected);
+  Consumer->SetExpected(diag::err_hlsl_expected_param);
   ASSERT_TRUE(Parser.Parse());
 
   ASSERT_TRUE(Consumer->IsSatisfied());
@@ -278,7 +278,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) {
   hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
 
   // Test correct diagnostic produced - end of stream
-  Consumer->SetExpected(diag::err_expected);
+  Consumer->SetExpected(diag::err_hlsl_expected_param);
   ASSERT_TRUE(Parser.Parse());
 
   ASSERT_TRUE(Consumer->IsSatisfied());