Handle case insensitivity properly in CCC ranges

The prior implementation didn't make a lot of sense, and couldn't
handle cases like `/(?i)[X-c]/`. This new approach uses simple case
matching to test if the character is within the range, then tests if
the uppercase or lowercase mappings are within the range.

Fixes swiftlang#395

Author: natecook1000

Sources/_StringProcessing/ConsumerInterface.swift

@@ -276,54 +276,48 @@ extension DSLTree.CustomCharacterClass.Member {
       }
       return c
     case let .range(low, high):
-      // TODO:
       guard let lhs = low.literalCharacterValue, lhs.hasExactlyOneScalar else {
         throw Unsupported("\(low) in range")
       }
       guard let rhs = high.literalCharacterValue, rhs.hasExactlyOneScalar else {
         throw Unsupported("\(high) in range")
       }
+      guard lhs <= rhs else {
+        throw Unsupported("Invalid range \(low)-\(high)")
+      }
 
+      let isCaseInsensitive = opts.isCaseInsensitive
       let isCharacterSemantic = opts.semanticLevel == .graphemeCluster
 
-      if opts.isCaseInsensitive {
-        let lhsLower = lhs.lowercased()
-        let rhsLower = rhs.lowercased()
-        guard lhsLower <= rhsLower else { throw Unsupported("Invalid range \(lhs)-\(rhs)") }
-        return { input, bounds in
-          // TODO: check for out of bounds?
-          let curIdx = bounds.lowerBound
-          if isCharacterSemantic {
-            guard input[curIdx].hasExactlyOneScalar else { return nil }
-            if (lhsLower...rhsLower).contains(input[curIdx].lowercased()) {
-              return input.index(after: curIdx)
-            }
-          } else {
-            if (lhsLower...rhsLower).contains(input.unicodeScalars[curIdx].properties.lowercaseMapping) {
-              return input.unicodeScalars.index(after: curIdx)
-            }
-          }
+      return { input, bounds in
+        // TODO: check for out of bounds?
+        let curIdx = bounds.lowerBound
+        let nextIndex = isCharacterSemantic
+          ? input.index(after: curIdx)
+          : input.unicodeScalars.index(after: curIdx)
+        if isCharacterSemantic && !input[curIdx].hasExactlyOneScalar {
           return nil
         }
-      } else {
-        guard lhs <= rhs else { throw Unsupported("Invalid range \(lhs)-\(rhs)") }
-        return { input, bounds in
-          // TODO: check for out of bounds?
-          let curIdx = bounds.lowerBound
-          if isCharacterSemantic {
-            guard input[curIdx].hasExactlyOneScalar else { return nil }
-            if (lhs...rhs).contains(input[curIdx]) {
-              return input.index(after: curIdx)
-            }
-          } else {
-            if (lhs...rhs).contains(Character(input.unicodeScalars[curIdx])) {
-              return input.unicodeScalars.index(after: curIdx)
-            }
-          }
+        let scalar = input.unicodeScalars[curIdx]
+        let scalarRange = lhs.unicodeScalars.first! ... rhs.unicodeScalars.first!
+        if scalarRange.contains(scalar) {
+          return nextIndex
+        }
+        if !isCaseInsensitive {
           return nil
         }
+        
+        let stringRange = String(lhs)...String(rhs)
+        if (scalar.properties.changesWhenLowercased
+            && stringRange.contains(scalar.properties.lowercaseMapping))
+          || (scalar.properties.changesWhenUppercased
+            && stringRange.contains(scalar.properties.uppercaseMapping)) {
+          return nextIndex
+        }
+        
+        return nil
       }
-
+      
     case let .custom(ccc):
       return try ccc.generateConsumer(opts)
 

Tests/RegexTests/MatchTests.swift

@@ -731,6 +731,33 @@ extension RegexTests {
     firstMatchTest(#"["abc"]+"#, input: #""abc""#, match: "abc",
                    syntax: .experimental)
     firstMatchTest(#"["abc"]+"#, input: #""abc""#, match: #""abc""#)
+    
+    // Case sensitivity and ranges.
+    for ch in "abcD" {
+      firstMatchTest("[a-cD]", input: String(ch), match: String(ch))
+    }
+    for ch in "ABCd" {
+      firstMatchTest("[a-cD]", input: String(ch), match: nil)
+    }
+
+    for ch in "abcABCdD" {
+      firstMatchTest("(?i)[a-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("(?i)[A-CD]", input: String(ch), match: String(ch))
+      firstMatchTest("(?iu)[a-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("(?iu)[A-CD]", input: String(ch), match: String(ch))
+    }
+
+    for ch in "XYZ[\\]^_`abcd" {
+      firstMatchTest("[X-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("[X-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("(?u)[X-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("(?u)[X-cd]", input: String(ch), match: String(ch))
+    }
+
+    for ch in "XYZ[\\]^_`abcxyzABCdD" {
+      firstMatchTest("(?i)[X-cd]", input: String(ch), match: String(ch))
+      firstMatchTest("(?iu)[X-cD]", input: String(ch), match: String(ch))
+    }
   }
 
   func testCharacterProperties() {