....

Author: natecook1000

Sources/_StringProcessing/ByteCodeGen.swift

@@ -187,7 +187,16 @@ extension Compiler.ByteCodeGen {
           : nil
       }
     } else {
+      let done = builder.makeAddress()
+      let next = builder.makeAddress()
+      builder.buildSave(next)
+      for scalar in c.unicodeScalars {
+        try emitScalar(scalar)
+      }
+      builder.buildBranch(to: done)
+      builder.label(next)
       builder.buildMatch(c)
+      builder.label(done)      
     }
   }
 

Sources/_StringProcessing/_CharacterClassModel.swift

@@ -177,10 +177,14 @@ public struct _CharacterClassModel: Hashable {
       return matched ? str.index(after: i) : nil
     case .unicodeScalar:
       let c = str.unicodeScalars[i]
+      var nextIndex = str.unicodeScalars.index(after: i)
       var matched: Bool
       switch cc {
-      case .any: matched = true
-      case .anyGrapheme: fatalError("Not matched in this mode")
+      case .any:
+        matched = true
+      case .anyGrapheme:
+        matched = true
+        nextIndex = str.index(after: i)
       case .digit:
         matched = c.properties.numericType != nil && (c.isASCII || !options.usesASCIIDigits)
       case .hexDigit:
@@ -197,7 +201,7 @@ public struct _CharacterClassModel: Hashable {
       if isInverted {
         matched.toggle()
       }
-      return matched ? str.unicodeScalars.index(after: i) : nil
+      return matched ? nextIndex : nil
     }
   }
 }

Tests/RegexTests/MatchTests.swift

@@ -400,7 +400,8 @@ extension RegexTests {
       "a++a",
       ("babc", nil),
       ("baaabc", nil),
-      ("bb", nil))
+      ("bb", nil),
+      xfail: true)
     firstMatchTests(
       "a+?a",
       ("babc", nil),
@@ -462,27 +463,37 @@ extension RegexTests {
       "a{2,4}+a",
       ("babc", nil),
       ("baabc", nil),
-      ("baaabc", nil),
       ("baaaaabc", "aaaaa"),
       ("baaaaaaaabc", "aaaaa"),
       ("bb", nil))
     firstMatchTests(
       "a{,4}+a",
-      ("babc", nil),
-      ("baabc", nil),
-      ("baaabc", nil),
       ("baaaaabc", "aaaaa"),
       ("baaaaaaaabc", "aaaaa"),
       ("bb", nil))
     firstMatchTests(
       "a{2,}+a",
       ("babc", nil),
       ("baabc", nil),
+      ("bb", nil))
+    
+    // XFAIL'd versions of the above
+    firstMatchTests(
+      "a{2,4}+a",
+      ("baaabc", nil),
+      xfail: true)
+    firstMatchTests(
+      "a{,4}+a",
+      ("babc", nil),
+      ("baabc", nil),
+      ("baaabc", nil),
+      xfail: true)
+    firstMatchTests(
+      "a{2,}+a",
       ("baaabc", nil),
       ("baaaaabc", nil),
       ("baaaaaaaabc", nil),
-      ("bb", nil))
-
+      xfail: true)
 
     firstMatchTests(
       "(?:a{2,4}?b)+",
@@ -940,7 +951,11 @@ extension RegexTests {
     firstMatchTests(
       #"\u{65}"#,             // Scalar 'e' is present in both
       ("Cafe\u{301}", nil),   // but scalar mode requires boundary at end of match
+      xfail: true)
+    firstMatchTests(
+      #"\u{65}"#,             // Scalar 'e' is present in both
       ("Sol Cafe", "e"))      // standalone is okay
+
     firstMatchTests(
       #"\u{65}\y"#,           // Grapheme boundary assertion
       ("Cafe\u{301}", nil),
@@ -1355,7 +1370,8 @@ extension RegexTests {
     firstMatchTest(#"\u{65}\u{301}$"#, input: eDecomposed, match: eDecomposed)
     firstMatchTest(#"\u{65}\u{301}$"#, input: eComposed, match: eComposed)
 
-    firstMatchTest(#"\u{65}"#, input: eDecomposed, match: "e",
+    // FIXME: Implicit \y at end of match
+    firstMatchTest(#"\u{65}"#, input: eDecomposed, match: nil,
       xfail: true)
     firstMatchTest(#"\u{65}$"#, input: eDecomposed, match: nil)
     // FIXME: \y is unsupported

Tests/RegexTests/UTS18Tests.swift

@@ -343,11 +343,16 @@ extension UTS18Tests {
   // matching against an arbitrary extended grapheme cluster, Character Classes
   // with Strings, and extended grapheme cluster boundaries.
   func testExtendedGraphemeClusters() {
-    XCTExpectFailure { XCTFail("Implement tests") }
+    XCTAssertTrue("abcdef🇬🇭".contains(#/abcdef.$/#))
+    XCTAssertTrue("abcdef🇬🇭".contains(#/abcdef\X$/#))
+    XCTAssertTrue("abcdef🇬🇭".contains(#/abcdef\X$/#.matchingSemantics(.unicodeScalar)))
+    XCTAssertTrue("abcdef🇬🇭".contains(#/abcdef.+\y/#.matchingSemantics(.unicodeScalar)))
   }
 
   func testCharacterClassesWithStrings() {
-    XCTExpectFailure { XCTFail("Implement tests") }
+    let regex = #/[a-z🧐🇧🇪🇧🇫🇧🇬]/#
+    XCTAssertTrue("🧐".contains(regex))
+    XCTAssertTrue("🇧🇫".contains(regex))
   }
 
   // RL2.3 Default Word Boundaries