Diagnose if hex literal does not contain any hex digits

Fixes #1214

rdar://104082735

Author: ahoppen

Sources/SwiftParser/Lexer/Cursor.swift

@@ -1328,17 +1328,18 @@ extension Lexer.Cursor {
     assert(zeroConsumed && xConsumed, "not a hex literal")
 
     // 0x[0-9a-fA-F][0-9a-fA-F_]*
-    if self.isAtEndOfFile {
-      // TODO: Diagnose invalid hex literal '0x'
-      return Lexer.Result(.integerLiteral)
+    guard let peeked = self.peek() else {
+      return Lexer.Result(.integerLiteral, error: (.expectedHexDigitInHexLiteral, self))
     }
-    guard let peeked = self.peek(), Unicode.Scalar(peeked).isHexDigit else {
-      let errorPos = self
-      self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
-      return Lexer.Result(
-        .integerLiteral,
-        error: (.invalidHexDigitInIntegerLiteral, errorPos)
-      )
+
+    guard Unicode.Scalar(peeked).isHexDigit else {
+      if Unicode.Scalar(peeked).isValidIdentifierContinuationCodePoint {
+        let errorPos = self
+        self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
+        return Lexer.Result(.integerLiteral, error: (.invalidHexDigitInIntegerLiteral, errorPos))
+      } else {
+        return Lexer.Result(.integerLiteral, error: (.expectedHexDigitInHexLiteral, self))
+      }
     }
 
     self.advance(while: { $0.isHexDigit || $0 == Unicode.Scalar("_") })
@@ -2128,9 +2129,6 @@ extension Lexer.Cursor {
     if tmp.advance(if: { Unicode.Scalar($0).isValidIdentifierContinuationCodePoint }) {
       // If this is a valid identifier continuation, but not a valid identifier
       // start, attempt to recover by eating more continuation characters.
-      //      if (EmitDiagnosticsIfToken) {
-      //        diagnose(CurPtr - 1, diag::lex_invalid_identifier_start_character)
-      //      }
       tmp.advance(while: { Unicode.Scalar($0).isValidIdentifierContinuationCodePoint })
       self = tmp
       return .lexemeContents(Lexer.Result(.identifier, error: (.invalidIdentifierStartCharacter, position: start)))

Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift

@@ -42,6 +42,7 @@ public enum StaticLexerError: String, DiagnosticMessage {
   case expectedClosingBraceInUnicodeEscape = #"expected '}' in \u{...} escape sequence"#
   case expectedDigitInFloatLiteral = "expected a digit in floating point exponent"
   case expectedHexCodeInUnicodeEscape = #"expected hexadecimal code in \u{...} escape sequence"#
+  case expectedHexDigitInHexLiteral = "expected hexadecimal digit (0-9, A-F) in integer literal"
   case invalidCharacter = "invalid character in source file"
   case invalidEscapeSequenceInStringLiteral = "invalid escape sequence in literal"
   case invalidIdentifierStartCharacter = "an identifier cannot begin with this character"
@@ -121,6 +122,7 @@ public extension SwiftSyntax.LexerError {
     case .expectedClosingBraceInUnicodeEscape: return StaticLexerError.expectedClosingBraceInUnicodeEscape
     case .expectedDigitInFloatLiteral: return StaticLexerError.expectedDigitInFloatLiteral
     case .expectedHexCodeInUnicodeEscape: return StaticLexerError.expectedHexCodeInUnicodeEscape
+    case .expectedHexDigitInHexLiteral: return StaticLexerError.expectedHexDigitInHexLiteral
     case .insufficientIndentationInMultilineStringLiteral:
       // This should be diagnosed when visiting the `StringLiteralExprSyntax`
       // inside `ParseDiagnosticsGenerator` but fall back to an error message

Sources/SwiftSyntax/LexerError.swift

@@ -21,6 +21,7 @@ public struct LexerError: Hashable {
     case expectedClosingBraceInUnicodeEscape
     case expectedDigitInFloatLiteral
     case expectedHexCodeInUnicodeEscape
+    case expectedHexDigitInHexLiteral
     case insufficientIndentationInMultilineStringLiteral
     case invalidBinaryDigitInIntegerLiteral
     case invalidCharacter

Tests/SwiftParserTest/LexerTests.swift

@@ -1208,4 +1208,20 @@ public class LexerTests: XCTestCase {
     )
   }
 
+  func testHexLiteralWithoutNumbers() {
+    AssertLexemes(
+      "0x1️⃣",
+      lexemes: [
+        LexemeSpec(.integerLiteral, text: "0x", error: "expected hexadecimal digit (0-9, A-F) in integer literal")
+      ]
+    )
+
+    AssertLexemes(
+      "0x1️⃣ ",
+      lexemes: [
+        LexemeSpec(.integerLiteral, text: "0x", trailing: " ", error: "expected hexadecimal digit (0-9, A-F) in integer literal")
+      ]
+    )
+  }
+
 }