(112770879) “Washington, D.c.” capitalized incorrectly (swiftlang#212)

* (112770879) “Washington, D.c.” capitalized incorrectly

Theoretically "." is a case-ignorable character, so "D.C." is conceptually the same as "DC", whose capitalized mapping would be "Dc". This behavior doesn't seem to align with real-world use cases well though. Workaround this by splitting the string with "." and titlecasing each substring individually.

* (112770879) “Washington, D.c.” capitalized incorrectly, cont.

For FoundationPreview: Move String comparison utilities from FoundationEssentials fo _FoundationInternals so they can be accessed from FoundationInternalization too.

Author: itingliu

Sources/FoundationEssentials/String/String+Essentials.swift

@@ -10,6 +10,46 @@
 //
 //===----------------------------------------------------------------------===//
 
+// MARK: - Exported Types
+@available(macOS 10.0, iOS 8.0, watchOS 2.0, tvOS 9.0, *)
+extension String {
+#if FOUNDATION_FRAMEWORK
+    public typealias CompareOptions = NSString.CompareOptions
+#else
+    /// These options apply to the various search/find and comparison methods (except where noted).
+    public struct CompareOptions : OptionSet, Sendable {
+        public let rawValue: UInt
+
+        public init(rawValue: UInt) {
+            self.rawValue = rawValue
+        }
+
+        public static let caseInsensitive = CompareOptions(rawValue: 1)
+        /// Exact character-by-character equivalence
+        public static let literal = CompareOptions(rawValue: 2)
+        /// Search from end of source string
+        public static let backwards = CompareOptions(rawValue: 4)
+        /// Search is limited to start (or end, if `.backwards`) of source string
+        public static let anchored  = CompareOptions(rawValue: 8)
+        /// Numbers within strings are compared using numeric value, that is,
+        /// Foo2.txt < Foo7.txt < Foo25.txt;
+        /// only applies to compare methods, not find
+        public static let numeric   = CompareOptions(rawValue: 64)
+        /// If specified, ignores diacritics (o-umlaut == o)
+        public static let diacriticInsensitive = CompareOptions(rawValue: 128)
+        /// If specified, ignores width differences ('a' == UFF41)
+        public static let widthInsensitive = CompareOptions(rawValue: 256)
+        /// If specified, comparisons are forced to return either `.orderedAscending`
+        /// or `.orderedDescending` if the strings are equivalent but not strictly equal,
+        /// for stability when sorting (e.g. "aaa" > "AAA" with `.caseInsensitive` specified)
+        public static let forcedOrdering = CompareOptions(rawValue: 512)
+        /// The search string is treated as an ICU-compatible regular expression;
+        /// if set, no other options can apply except `.caseInsensitive` and `.anchored`
+        public static let regularExpression = CompareOptions(rawValue: 1024)
+    }
+#endif // FOUNDATION_FRAMEWORK
+}
+
 @available(macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, *)
 extension String {
     func _capitalized() -> String {

Sources/FoundationInternationalization/Calendar/Calendar_Enumerate.swift

@@ -2131,16 +2131,3 @@ extension Calendar.Component {
     }
 }
 
-#if !FOUNDATION_FRAMEWORK
-extension ComparisonResult {
-    init<T: Comparable>(_ t1: T, _ t2: T) {
-        if t1 < t2 {
-            self = .orderedAscending
-        } else if t1 > t2 {
-            self = .orderedDescending
-        } else {
-            self = .orderedSame
-        }
-    }
-}
-#endif

Sources/FoundationInternationalization/ICU/ICU+CaseMap.swift

@@ -71,6 +71,19 @@ extension ICU {
                 }
             }
         }
+        
+        func titlecase(_ s: Substring) -> String? {
+            lock.withLock {
+                var s = s
+                return s.withUTF8 { srcBuf in
+                    srcBuf.withMemoryRebound(to: CChar.self) { buffer in
+                        _withResizingCharBuffer { destBuf, destSize, status in
+                            ucasemap_utf8ToTitle(casemap, destBuf, destSize, buffer.baseAddress!, Int32(buffer.count), &status)
+                        }
+                    }
+                }
+            }
+        }
 
         func titlecase(_ s: String) -> String? {
             // `ucasemap_utf8ToTitle` isn't thread-safe

Sources/FoundationInternationalization/String/String+Locale.swift

@@ -21,11 +21,21 @@ extension String {
         return lowered
     }
 
-    func _capitalized(with  locale: Locale?) -> String {
-        guard let casemap = ICU.CaseMap.caseMappingForLocale(locale?.identifier), let titled = casemap.titlecase(self) else {
+    func _capitalized(with locale: Locale?) -> String {
+        guard let casemap = ICU.CaseMap.caseMappingForLocale(locale?.identifier) else {
             return capitalized
         }
-        return titled
+        
+        // Theoretically "." is a case-ignorable character, so the character after "." is not uppercased. This results in "D.c." for "D.C".
+        // Handle this special case by splitting the string with "." and titlecasing each substring individually.
+        var result = ""
+        try! self[...]._enumerateComponents(separatedBy: ".", options: []) { substr, isLastComponent in
+            result += casemap.titlecase(substr) ?? substr.capitalized
+            if !isLastComponent {
+                result += "."
+            }
+        }
+        return result
     }
 
     func _uppercased(with locale: Locale?) -> String {

Sources/FoundationEssentials/ComparisonResult.swift renamed to Sources/_FoundationInternals/ComparisonResult.swift

@@ -10,46 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// MARK: - Exported Types
-@available(macOS 10.0, iOS 8.0, watchOS 2.0, tvOS 9.0, *)
-extension String {
-#if FOUNDATION_FRAMEWORK
-    public typealias CompareOptions = NSString.CompareOptions
-#else
-    /// These options apply to the various search/find and comparison methods (except where noted).
-    public struct CompareOptions : OptionSet, Sendable {
-        public let rawValue: UInt
-
-        public init(rawValue: UInt) {
-            self.rawValue = rawValue
-        }
-
-        static let caseInsensitive = CompareOptions(rawValue: 1)
-        /// Exact character-by-character equivalence
-        static let literal = CompareOptions(rawValue: 2)
-        /// Search from end of source string
-        static let backwards = CompareOptions(rawValue: 4)
-        /// Search is limited to start (or end, if `.backwards`) of source string
-        static let anchored  = CompareOptions(rawValue: 8)
-        /// Numbers within strings are compared using numeric value, that is,
-        /// Foo2.txt < Foo7.txt < Foo25.txt;
-        /// only applies to compare methods, not find
-        static let numeric   = CompareOptions(rawValue: 64)
-        /// If specified, ignores diacritics (o-umlaut == o)
-        static let diacriticInsensitive = CompareOptions(rawValue: 128)
-        /// If specified, ignores width differences ('a' == UFF41)
-        static let widthInsensitive = CompareOptions(rawValue: 256)
-        /// If specified, comparisons are forced to return either `.orderedAscending`
-        /// or `.orderedDescending` if the strings are equivalent but not strictly equal,
-        /// for stability when sorting (e.g. "aaa" > "AAA" with `.caseInsensitive` specified)
-        static let forcedOrdering = CompareOptions(rawValue: 512)
-        /// The search string is treated as an ICU-compatible regular expression;
-        /// if set, no other options can apply except `.caseInsensitive` and `.anchored`
-        static let regularExpression = CompareOptions(rawValue: 1024)
-    }
-#endif // FOUNDATION_FRAMEWORK
-}
-
 extension UTF8.CodeUnit {
     static let newline: Self = 0x0A
     static let carriageReturn: Self = 0x0D
@@ -676,20 +636,26 @@ extension Substring {
 
     func _components(separatedBy separator: Substring, options: String.CompareOptions = []) throws -> [String] {
         var result = [String]()
+        try _enumerateComponents(separatedBy: separator, options: options) { substr, _ in
+            result.append(String(substr))
+        }
+        return result
+    }
+
+    // Only throws when using `.regularExpression` option
+    func _enumerateComponents(separatedBy separator: Substring, options: String.CompareOptions = [], withBlock block: (_ component: Substring, _ isLastComponent: Bool) -> ()) throws {
         var searchStart = startIndex
         while searchStart < endIndex {
             let r = try self[searchStart...]._range(of: separator, options: options)
             guard let r, !r.isEmpty else {
                 break
             }
 
-            result.append(String(self[searchStart ..< r.lowerBound]))
+            block(self[searchStart ..< r.lowerBound], false)
             searchStart = r.upperBound
         }
 
-        result.append(String(self[searchStart..<endIndex]))
-
-        return result
+        block(self[searchStart..<endIndex], true)
     }
 }
 

Sources/FoundationEssentials/BuiltInUnicodeScalarSet.swift renamed to Sources/_FoundationInternals/String/BuiltInUnicodeScalarSet.swift

@@ -45,6 +45,7 @@ final class StringLocaleTests: XCTestCase {
             test("İİ", "İi")
             test("II", "Iı")
             test("«ijs»", "«İjs»")
+            test("ijs.ıi", "İjs.Ii")
         }
 
         do {
@@ -55,12 +56,31 @@ final class StringLocaleTests: XCTestCase {
             test("II", "Ii")
             test("«ijs»", "«IJs»")
             test("ijssEl iglOo IJSSEL", "IJssel Igloo IJssel")
+            test("ijssEl.ijSSEL", "IJssel.IJssel")
         }
 
         do {
             locale = Locale(identifier: "el")
             test("άυλος", "Άυλος")
         }
+
+        do {
+            locale = Locale(identifier: "en_US")
+            test("washington d.c.", "Washington D.C.")
+            test("washington D.c.", "Washington D.C.")
+            test("washington d.C.", "Washington D.C.")
+
+            test("washington d. c.", "Washington D. C.")
+            test("washington d. C.", "Washington D. C.")
+
+            test("washington.D.C.", "Washington.D.C.")
+
+            test("u.s.a.", "U.S.A.")
+            test("U.S.A.", "U.S.A.")
+
+            test("example county. happy. SOC'y, INC. V. COMM'R, 123 F.24d 314 (2d Cir. 1990).", "Example County. Happy. Soc'y, Inc. V. Comm'r, 123 F.24d 314 (2d Cir. 1990).")
+            test("3.dollars", "3.Dollars")
+        }
     }
 
     func testUppercase_localized() {