Support NS/CFURL re-core in Swift (#1238)

* (146349351) Support NS/CFURL re-core in Swift

* Fix .fileSystemPath() calls in Windows test

* Use encoded strings for .absoluteURL, fix NSURL bridging and CFURL lastPathComponent edge cases

* Add workaround for crash on Linux

* Fix typo

Author: jrflat

Sources/FoundationEssentials/CodableUtilities.swift

@@ -166,6 +166,7 @@ extension UInt8 {
     internal static var _exclamation: UInt8 { UInt8(ascii: "!") }
     internal static var _ampersand: UInt8 { UInt8(ascii: "&") }
     internal static var _pipe: UInt8 { UInt8(ascii: "|") }
+    internal static var _percent: UInt8 { UInt8(ascii: "%") }
     internal static var _period: UInt8 { UInt8(ascii: ".") }
     internal static var _e: UInt8 { UInt8(ascii: "e") }
     internal static var _E: UInt8 { UInt8(ascii: "E") }

Sources/FoundationEssentials/String/String+Path.swift

@@ -210,10 +210,11 @@ extension String {
         guard !pathExtension.isEmpty, validatePathExtension(pathExtension) else {
             return self
         }
+        if self == "/" { return "/.\(pathExtension)"}
         var result = self._droppingTrailingSlashes
-        guard result != "/" else {
+        if result == "/" {
             // Path was all slashes
-            return self + ".\(pathExtension)"
+            return Substring(self.utf8.dropLast()) + ".\(pathExtension)/"
         }
         result += ".\(pathExtension)"
         if utf8.last == ._slash {
@@ -404,6 +405,13 @@ extension String {
         }
     }
 
+    internal var _droppingTrailingSlash: String {
+        guard utf8.last == ._slash, utf8.count > 1 else {
+            return self
+        }
+        return String(Substring(utf8.dropLast()))
+    }
+
     internal var _droppingTrailingSlashes: String {
         guard !self.isEmpty else {
             return self

Sources/FoundationEssentials/URL/CMakeLists.txt

@@ -14,6 +14,10 @@
 
 target_sources(FoundationEssentials PRIVATE
     URL.swift
+    URL_Bridge.swift
+    URL_ObjC.swift
+    URL_Protocol.swift
+    URL_Swift.swift
     URLComponents.swift
     URLComponents_ObjC.swift
     URLParser.swift)

Sources/FoundationEssentials/URL/URL.swift

@@ -489,6 +489,56 @@ public struct URLComponents: Hashable, Equatable, Sendable {
             return result
         }
 
+        internal func _uncheckedString(original: Bool) -> String {
+            let componentsToDecode = original ? urlParseInfo?.encodedComponents ?? [] : []
+            var result = ""
+            if let scheme {
+                result += "\(scheme):"
+            }
+            if hasAuthority {
+                result += "//"
+            }
+            if componentsToDecode.contains(.user), let user {
+                result += user
+            } else if let percentEncodedUser {
+                result += percentEncodedUser
+            }
+            if componentsToDecode.contains(.password), let password {
+                result += ":\(password)"
+            } else if let percentEncodedPassword {
+                result += ":\(percentEncodedPassword)"
+            }
+            if percentEncodedUser != nil || percentEncodedPassword != nil {
+                result += "@"
+            }
+            if componentsToDecode.contains(.host), let host {
+                result += host
+            } else if let encodedHost {
+                result += encodedHost
+            }
+            if parseInfoIsValidForPort, let portString = urlParseInfo?.portString {
+                result += ":\(portString)"
+            } else if let port {
+                result += ":\(port)"
+            }
+            if componentsToDecode.contains(.path) {
+                result += path
+            } else {
+                result += percentEncodedPath
+            }
+            if componentsToDecode.contains(.query), let query {
+                result += "?\(query)"
+            } else if let percentEncodedQuery {
+                result += "?\(percentEncodedQuery)"
+            }
+            if componentsToDecode.contains(.fragment), let fragment {
+                result += "#\(fragment)"
+            } else if let percentEncodedFragment {
+                result += "#\(percentEncodedFragment)"
+            }
+            return result
+        }
+
         func rangeOf(_ component: Component) -> Range<String.Index>? {
             if let urlParseInfo, parseInfoIsValidForAllRanges {
                 switch component {
@@ -694,6 +744,21 @@ public struct URLComponents: Hashable, Equatable, Sendable {
         self.components = _URLComponents(parseInfo: parseInfo)
     }
 
+    #if FOUNDATION_FRAMEWORK
+    internal init?(url: _BridgedURL, resolvingAgainstBaseURL resolve: Bool) {
+        let string: String
+        if resolve {
+            string = url.absoluteString
+        } else {
+            string = url.relativeString
+        }
+        guard let components = _URLComponents(string: string) else {
+            return nil
+        }
+        self.components = components
+    }
+    #endif
+
     /// Returns a URL created from the URLComponents.
     ///
     /// If the URLComponents has an authority component (user, password, host or port) and a path component, then the path must either begin with "/" or be an empty string. If the NSURLComponents does not have an authority component (user, password, host or port) and has a path component, the path component must not start with "//". If those requirements are not met, nil is returned.
@@ -729,6 +794,12 @@ public struct URLComponents: Hashable, Equatable, Sendable {
         components.string
     }
 
+    /// For use by URL to get a non-nil string, potentially decoding components to return an original string.
+    /// This does not provide any validation, since URL is historically less strict than URLComponents.
+    internal func _uncheckedString(original: Bool) -> String {
+        components._uncheckedString(original: original)
+    }
+
     /// The scheme subcomponent of the URL.
     ///
     /// The getter for this property removes any percent encoding this component may have (if the component allows percent encoding). Setting this property assumes the subcomponent or component string is not percent encoded and will add percent encoding (if the component allows percent encoding).

Sources/FoundationEssentials/URL/URLComponents.swift

@@ -34,8 +34,8 @@ extension NSURLComponents {
         return _NSSwiftURLComponents(components: components)
     }
 
-    static func _parseString(_ string: String, encodingInvalidCharacters: Bool, compatibility: URLParserCompatibility.RawValue) -> String? {
-        return RFC3986Parser.parse(urlString: string, encodingInvalidCharacters: encodingInvalidCharacters, compatibility: .init(rawValue: compatibility))?.urlString
+    static func _parseString(_ string: String, encodingInvalidCharacters: Bool, allowEmptyScheme: Bool) -> String? {
+        return RFC3986Parser.parse(urlString: string, encodingInvalidCharacters: encodingInvalidCharacters, allowEmptyScheme: allowEmptyScheme)?.urlString
     }
 }