Ban confusable multi-scalar ASCII characters

Ban multi-scalar characters that start with ASCII,
and are not letters, numbers, or `\r\n`. These
may be confused with metacharacters and as such
should be spelled explicitly.

Author: hamishknight

Sources/_RegexParser/Regex/Parse/Diagnostics.swift

@@ -42,6 +42,7 @@ enum ParseError: Error, Hashable {
   case expectedNonEmptyContents
   case expectedEscape
   case invalidEscape(Character)
+  case confusableCharacter(Character)
 
   case cannotReferToWholePattern
 
@@ -128,6 +129,8 @@ extension ParseError: CustomStringConvertible {
       return "expected escape sequence"
     case .invalidEscape(let c):
       return "invalid escape sequence '\\\(c)'"
+    case .confusableCharacter(let c):
+      return "'\(c)' is confusable for a metacharacter; use '\\u{...}' instead"
     case .cannotReferToWholePattern:
       return "cannot refer to whole pattern here"
     case .quantifierRequiresOperand(let q):

Sources/_RegexParser/Regex/Parse/LexicalAnalysis.swift

@@ -1982,10 +1982,21 @@ extension Source {
 
       case "]":
         assert(!customCC, "parser should have prevented this")
-        fallthrough
+        break
 
-      default: return .char(char)
+      default:
+        // Reject non-letter non-number non-`\r\n` ASCII characters that have
+        // multiple scalars. These may be confusable for metacharacters, e.g
+        // `[\u{301}]` wouldn't be interpreted as a custom character class due
+        // to the combining accent (assuming it is literal, not `\u{...}`).
+        let scalars = char.unicodeScalars
+        if scalars.count > 1 && scalars.first!.isASCII && char != "\r\n" &&
+            !char.isLetter && !char.isNumber {
+          throw ParseError.confusableCharacter(char)
+        }
+        break
       }
+      return .char(char)
     }
     guard let kind = kind else { return nil }
     return AST.Atom(kind.value, kind.location)

Tests/RegexTests/MatchTests.swift

@@ -218,6 +218,12 @@ extension RegexTests {
     firstMatchTest(
       #"abc\d"#, input: "xyzabc123", match: "abc1")
 
+    // MARK: Allowed combining characters
+
+    firstMatchTest("e\u{301}", input: "e\u{301}", match: "e\u{301}")
+    firstMatchTest("1\u{358}", input: "1\u{358}", match: "1\u{358}")
+    firstMatchTest(#"\ \#u{361}"#, input: " \u{361}", match: " \u{361}")
+
     // MARK: Alternations
 
     firstMatchTest(

Tests/RegexTests/ParseTests.swift

@@ -394,6 +394,12 @@ extension RegexTests {
       #"abc\d"#,
       concat("a", "b", "c", escaped(.decimalDigit)))
 
+    // MARK: Allowed combining characters
+
+    parseTest("e\u{301}", "e\u{301}")
+    parseTest("1\u{358}", "1\u{358}")
+    parseTest(#"\ \#u{361}"#, " \u{361}")
+
     // MARK: Alternations
 
     parseTest(
@@ -476,6 +482,8 @@ extension RegexTests {
     parseTest(#"\u{    a   }"#, scalar("\u{A}"))
     parseTest(#"\u{  a  }\u{ B }"#, concat(scalar("\u{A}"), scalar("\u{B}")))
 
+    parseTest(#"[\u{301}]"#, charClass(scalar_m("\u{301}")))
+
     // MARK: Scalar sequences
 
     parseTest(#"\u{A bC}"#, scalarSeq("\u{A}", "\u{BC}"))
@@ -2554,6 +2562,18 @@ extension RegexTests {
     diagnosticTest(#"\˂"#, .invalidEscape("˂"))
     diagnosticTest(#"\d\#u{301}"#, .invalidEscape("d\u{301}"))
 
+    // MARK: Confusable characters
+
+    diagnosticTest("[\u{301}]", .confusableCharacter("[\u{301}"))
+    diagnosticTest("(\u{358})", .confusableCharacter("(\u{358}"))
+    diagnosticTest("{\u{35B}}", .confusableCharacter("{\u{35B}"))
+    diagnosticTest(#"\\#u{35C}"#, .confusableCharacter(#"\\#u{35C}"#))
+    diagnosticTest("^\u{35D}", .confusableCharacter("^\u{35D}"))
+    diagnosticTest("$\u{35E}", .confusableCharacter("$\u{35E}"))
+    diagnosticTest(".\u{35F}", .confusableCharacter(".\u{35F}"))
+    diagnosticTest("|\u{360}", .confusableCharacter("|\u{360}"))
+    diagnosticTest(" \u{361}", .confusableCharacter(" \u{361}"))
+
     // MARK: Character properties
 
     diagnosticTest(#"\p{Lx}"#, .unknownProperty(key: nil, value: "Lx"))