Fix \o parsing crash

This was caused by the fact that we'd walk into
`expectUnicodeScalar` if we saw `\o`, but we only
want to parse `\o{`. Instead, change it to be a `lex..`
method, and bail if we don't lex a scalar.

Author: hamishknight

Sources/_RegexParser/Regex/Parse/LexicalAnalysis.swift

@@ -422,8 +422,8 @@ extension Parser {
     return .scalarSequence(.init(scalars, trivia: trivia))
   }
 
-  /// Eat a scalar off the front, starting from after the
-  /// backslash and base character (e.g. `\u` or `\x`).
+  /// Try to eat a scalar off the front, starting from after the backslash and
+  /// base character (e.g. `\u` or `\x`).
   ///
   ///     UniScalar -> 'u{' UniScalarSequence '}'
   ///                | 'u'  HexDigit{4}
@@ -433,18 +433,16 @@ extension Parser {
   ///                | 'o{' OctalDigit{1...} '}'
   ///                | '0' OctalDigit{0...3}
   ///
-  mutating func expectUnicodeScalar(
-    escapedCharacter base: Character
-  ) -> AST.Atom.Kind {
-    recordLoc { p in
+  mutating func lexUnicodeScalar() -> AST.Atom.Kind? {
+    tryEating { p in
 
       func nullScalar() -> AST.Atom.Scalar {
         .init(UnicodeScalar(0), p.loc(p.src.currentPosition))
       }
 
       // TODO: PCRE offers a different behavior if PCRE2_ALT_BSUX is set.
-      switch base {
-      // Hex numbers.
+      switch p.tryEat() {
+        // Hex numbers.
       case "u" where p.tryEat("{"):
         return p.expectUnicodeScalarSequence(eating: "}")
 
@@ -469,7 +467,7 @@ extension Parser {
       case "U":
         return .scalar(p.expectUnicodeScalar(numDigits: 8))
 
-      // Octal numbers.
+        // Octal numbers.
       case "o" where p.tryEat("{"):
         let str = p.lexUntil(eating: "}")
         return .scalar(p.validateUnicodeScalar(str, .octal))
@@ -485,10 +483,9 @@ extension Parser {
         return .scalar(p.validateUnicodeScalar(digits, .octal))
 
       default:
-        p.unreachable("Unexpected scalar start")
-        return .scalar(nullScalar())
+        return nil
       }
-    }.value
+    }
   }
 
   /// Try to consume a quantifier
@@ -1739,6 +1736,11 @@ extension Parser {
         return ref
       }
 
+      // Hexadecimal and octal unicode scalars.
+      if let scalar = p.lexUnicodeScalar() {
+        return scalar
+      }
+
       guard let charLoc = p.tryEatWithLoc() else {
         p.errorAtCurrentPosition(.expectedEscape)
         return .invalid
@@ -1752,14 +1754,6 @@ extension Parser {
         return .escaped(builtin)
       }
 
-      switch char {
-      // Hexadecimal and octal unicode scalars.
-      case "u", "x", "U", "o", "0":
-        return p.expectUnicodeScalar(escapedCharacter: char)
-      default:
-        break
-      }
-
       // We only allow unknown escape sequences for non-letter non-number ASCII,
       // and non-ASCII whitespace.
       // TODO: Once we have fix-its, suggest a `0` prefix for octal `[\7]`.

Tests/RegexTests/ParseTests.swift

@@ -2800,6 +2800,8 @@ extension RegexTests {
 
     diagnosticTest("\\", .expectedEscape)
 
+    diagnosticTest(#"\o"#, .invalidEscape("o"))
+
     // TODO: Custom diagnostic for control sequence
     diagnosticTest(#"\c"#, .unexpectedEndOfInput)