[SR-7749] Poor performance of String.replacingOccurrences(of:with:) in corelibs-foundation

This supercedes swiftlang#1620.

Author: kevints

Foundation/NSString.swift

@@ -1130,7 +1130,7 @@ extension NSString {
         }
         return ""
     }
-    
+
     open func replacingOccurrences(of target: String, with replacement: String, options: CompareOptions = [], range searchRange: NSRange) -> String {
         if options.contains(.regularExpression) {
             return _stringByReplacingOccurrencesOfRegularExpressionPattern(target, withTemplate: replacement, options: options, range: searchRange)
@@ -1462,19 +1462,38 @@ extension NSMutableString {
         if options.contains(.regularExpression) {
             return _replaceOccurrencesOfRegularExpressionPattern(target, withTemplate:replacement, options:options, range: searchRange)
         }
-        
 
-        if let findResults = CFStringCreateArrayWithFindResults(kCFAllocatorSystemDefault, _cfObject, target._cfObject, CFRange(searchRange), options._cfValue(true)) {
-            let numOccurrences = CFArrayGetCount(findResults)
+        guard let findResults = CFStringCreateArrayWithFindResults(kCFAllocatorSystemDefault, _cfObject, target._cfObject, CFRange(searchRange), options._cfValue(true)) else {
+             return 0
+        }
+        let numOccurrences = CFArrayGetCount(findResults)
+
+        return withExtendedLifetime(findResults) {
+            guard type(of: self) == NSMutableString.self else {
+                // If we're dealing with non NSMutableString, mutations must go through `replaceCharacters` (documented behavior)
+                for cnt in 0..<numOccurrences {
+                    let rangePtr = CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)
+                    replaceCharacters(in: NSRange(rangePtr!.load(as: CFRange.self)), with: replacement)
+                }
+
+                return numOccurrences
+            }
+
+            var newStorage = Substring()
+            var sourceStringCurrentIndex = _storage.startIndex
             for cnt in 0..<numOccurrences {
-                let rangePtr = CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)
-                replaceCharacters(in: NSRange(rangePtr!.load(as: CFRange.self)), with: replacement)
+                let rangePtr = CFArrayGetValueAtIndex(findResults, backwards ? numOccurrences - cnt - 1 : cnt)
+                let range = NSRange(rangePtr!.load(as: CFRange.self))
+                let matchStartIndex = String.Index(utf16Offset: range.location, in: _storage)
+                let matchEndIndex = String.Index(utf16Offset: range.location + range.length, in: _storage)
+                newStorage += _storage[sourceStringCurrentIndex..<matchStartIndex]
+                newStorage += replacement
+                sourceStringCurrentIndex = matchEndIndex
             }
+            newStorage += _storage[sourceStringCurrentIndex ..< _storage.endIndex]
+            _storage = String(newStorage)
             return numOccurrences
-        } else {
-            return 0
         }
-
     }
 
     public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer?) -> Bool {

TestFoundation/TestNSString.swift

@@ -1413,6 +1413,64 @@ extension TestNSString {
         XCTAssertEqual(str4.replacingOccurrences(of: "\n\r", with: " "), "Hello\r\rworld.")
     }
 
+    func test_replacingOccurrencesInSubclass() {
+        class TestMutableString: NSMutableString {
+            private var wrapped: NSMutableString
+            var replaceCharactersCount: Int = 0
+
+            override var length: Int {
+                return wrapped.length
+            }
+
+            override func character(at index: Int) -> unichar {
+                return wrapped.character(at: index)
+            }
+
+            override func replaceCharacters(in range: NSRange, with aString: String) {
+                defer { replaceCharactersCount += 1 }
+                wrapped.replaceCharacters(in: range, with: aString)
+            }
+
+            override func mutableCopy(with zone: NSZone? = nil) -> Any {
+                return wrapped.mutableCopy()
+            }
+
+            required init(stringLiteral value: StaticString) {
+                wrapped = .init(stringLiteral: value)
+                super.init(stringLiteral: value)
+            }
+
+            required init(capacity: Int) {
+                fatalError("init(capacity:) has not been implemented")
+            }
+
+            required init(string aString: String) {
+                fatalError("init(string:) has not been implemented")
+            }
+
+            required convenience init?(coder aDecoder: NSCoder) {
+                fatalError("init(coder:) has not been implemented")
+            }
+
+            required init(characters: UnsafePointer<unichar>, length: Int) {
+                fatalError("init(characters:length:) has not been implemented")
+            }
+
+            required convenience init(extendedGraphemeClusterLiteral value: StaticString) {
+                fatalError("init(extendedGraphemeClusterLiteral:) has not been implemented")
+            }
+
+            required convenience init(unicodeScalarLiteral value: StaticString) {
+                fatalError("init(unicodeScalarLiteral:) has not been implemented")
+            }
+        }
+
+        let testString = TestMutableString(stringLiteral: "ababab")
+        XCTAssertEqual(testString.replacingOccurrences(of: "ab", with: "xx"), "xxxxxx")
+        XCTAssertEqual(testString.replaceCharactersCount, 3)
+    }
+
+
     func test_fileSystemRepresentation() {
         let name = "☃" as NSString
         let result = name.fileSystemRepresentation