review comments: fix handling of signed ints

- update Lexer to allow '+' prefix to denote a signed positive integer
- add missing errors when we expect an unsigned int for parameters
- add tests to show lexing of positive signed integer and unsigned
integer

Author: inbelic

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -6,19 +6,20 @@ namespace root_signature {
 
 // Lexer Definitions
 
-static bool IsPreprocessorNumberChar(char C) {
+static bool IsNumberChar(char C) {
   // TODO: extend for float support with or without hexadecimal/exponent
   return isdigit(C); // integer support
 }
 
 bool RootSignatureLexer::LexNumber(RootSignatureToken &Result) {
   // NumericLiteralParser does not handle the sign so we will manually apply it
-  Result.Signed = Buffer.front() == '-';
+  bool Negative = Buffer.front() == '-';
+  Result.Signed = Negative || Buffer.front() == '+';
   if (Result.Signed)
     AdvanceBuffer();
 
   // Retrieve the possible number
-  StringRef NumSpelling = Buffer.take_while(IsPreprocessorNumberChar);
+  StringRef NumSpelling = Buffer.take_while(IsNumberChar);
 
   // Parse the numeric value and do semantic checks on its specification
   clang::NumericLiteralParser Literal(NumSpelling, SourceLoc,
@@ -35,7 +36,7 @@ bool RootSignatureLexer::LexNumber(RootSignatureToken &Result) {
     if (Literal.GetIntegerValue(X))
       return true; // TODO: Report overflow error
 
-    X = Result.Signed ? -X : X;
+    X = Negative ? -X : X;
     Result.IntLiteral = (uint32_t)X.getZExtValue();
   } else {
     return true; // TODO: report unsupported number literal specification
@@ -84,7 +85,7 @@ bool RootSignatureLexer::LexToken(RootSignatureToken &Result) {
   }
 
   // Numeric constant
-  if (isdigit(C) || C == '-')
+  if (isdigit(C) || C == '-' || C == '+')
     return LexNumber(Result);
 
   // All following tokens require at least one additional character
@@ -101,7 +102,8 @@ bool RootSignatureLexer::LexToken(RootSignatureToken &Result) {
     if (LexNumber(Result))
       return true;
 
-    // Lex number could also parse a float so ensure it was an unsigned int
+    // Lex number could also parse a signed int/float so ensure it was an
+    // unsigned int
     if (Result.Kind != TokenKind::int_literal || Result.Signed)
       return true; // Return invalid number literal for register error
 

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -105,6 +105,8 @@ TEST_F(ParseHLSLRootSignatureTest, LexValidTokensTest) {
     shader_visibility_pixel
     shader_visibility_amplification
     shader_visibility_mesh
+
+    42 +42
   )cc";
 
   TrivialModuleLoader ModLoader;
@@ -121,6 +123,8 @@ TEST_F(ParseHLSLRootSignatureTest, LexValidTokensTest) {
   SmallVector<TokenKind> Expected = {
 #define TOK(NAME) TokenKind::NAME,
 #include "clang/Parse/HLSLRootSignatureTokenKinds.def"
+      TokenKind::int_literal,
+      TokenKind::int_literal,
   };
 
   CheckTokens(Tokens, Expected);