Merge branch 'swiftlang:main' into proposal/progress-reporter

Author: chloe-yeo

.github/workflows/pull_request.yml

@@ -0,0 +1,24 @@
+name: Pull request
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+jobs:
+  tests:
+    name: Test
+    uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
+    with:
+      linux_swift_versions: '["nightly-main"]'
+      windows_swift_versions: '["nightly-main"]'
+
+  soundness:
+    name: Soundness
+    uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
+    with:
+      license_header_check_project_name: "Swift.org"
+      license_header_check_enabled: false
+      docs_check_enabled: false
+      format_check_enabled: false
+      unacceptable_language_check_enabled: false
+      api_breakage_check_enabled: false

Sources/FoundationEssentials/Data/Data+Writing.swift

@@ -171,7 +171,7 @@ private func createTemporaryFile(at destinationPath: String, inPath: PathOrURL,
             guard _mktemp_s(templateFileSystemRep, strlen(templateFileSystemRep) + 1) == 0 else {
                 throw CocoaError.errorWithFilePath(inPath, errno: errno, reading: false, variant: variant)
             }
-            let fd = String(cString: templateFileSystemRep).withCString(encodedAs: UTF16.self) {
+            let fd = try String(cString: templateFileSystemRep).withNTPathRepresentation {
                 openFileDescriptorProtected(path: $0, flags: _O_BINARY | _O_CREAT | _O_EXCL | _O_RDWR, options: options)
             }
 #else

Sources/FoundationEssentials/FileManager/FileManager+Directories.swift

@@ -257,36 +257,6 @@ extension _FileManagerImpl {
         try fileManager.createDirectory(atPath: path, withIntermediateDirectories: createIntermediates, attributes: attributes)
     }
 
-#if os(Windows)
-    /// If `path` is absolute, this is the same as `path.withNTPathRepresentation`.
-    /// If `path` is relative, this creates an absolute path of `path` relative to `currentDirectoryPath` and runs
-    /// `body` with that path.
-    private func withAbsoluteNTPathRepresentation<Result>(
-        of path: String,
-        _ body: (UnsafePointer<WCHAR>) throws -> Result
-    ) throws -> Result {
-        try path.withNTPathRepresentation { pwszPath in
-            if !PathIsRelativeW(pwszPath) {
-                // We already have an absolute path. Nothing to do
-                return try body(pwszPath)
-            }
-            guard let currentDirectoryPath else {
-                preconditionFailure("We should always have a current directory on Windows")
-            }
-
-            // We have a relateive path. Make it absolute.
-            let absoluteUrl = URL(
-                filePath: path,
-                directoryHint: .isDirectory,
-                relativeTo: URL(filePath: currentDirectoryPath, directoryHint: .isDirectory)
-            )
-            return try absoluteUrl.path.withNTPathRepresentation { pwszPath in
-                return try body(pwszPath)
-            }
-        }
-    }
-#endif
-    
     func createDirectory(
         atPath path: String,
         withIntermediateDirectories createIntermediates: Bool,
@@ -301,7 +271,7 @@ extension _FileManagerImpl {
         if createIntermediates {
             // `SHCreateDirectoryExW` requires an absolute path while `CreateDirectoryW` works based on the current working
             // directory.
-            try withAbsoluteNTPathRepresentation(of: path) { pwszPath in
+            try path.withNTPathRepresentation { pwszPath in
                 let errorCode = SHCreateDirectoryExW(nil, pwszPath, &saAttributes)
                 guard let errorCode = DWORD(exactly: errorCode) else {
                     // `SHCreateDirectoryExW` returns `Int` but all error codes are defined in terms of `DWORD`, aka

Sources/FoundationEssentials/FileManager/FileManager+SymbolicLinks.swift

@@ -64,7 +64,7 @@ extension _FileManagerImpl {
 
         try path.withNTPathRepresentation { lpSymlinkFileName in
             try destPath.withFileSystemRepresentation {
-                try String(cString: $0!).withCString(encodedAs: UTF16.self) { lpTargetFileName in
+                try String(cString: $0!).withNTPathRepresentation(relative: true) { lpTargetFileName in
                     if CreateSymbolicLinkW(lpSymlinkFileName, lpTargetFileName, SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE | (bIsDirectory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0)) == 0 {
                         throw CocoaError.errorWithFilePath(path, win32: GetLastError(), reading: false)
                     }

Sources/FoundationEssentials/FileManager/FileOperations.swift

@@ -829,7 +829,7 @@ enum _FileOperations {
         try src.withNTPathRepresentation { pwszSource in
             var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = .init()
             guard GetFileAttributesExW(pwszSource, GetFileExInfoStandard, &faAttributes) else {
-                throw CocoaError.errorWithFilePath(.fileReadNoSuchFile, src, variant: bCopyFile ? "Copy" : "Link", source: src, destination: dst)
+                throw CocoaError.errorWithFilePath(src, win32: GetLastError(), reading: true, variant: bCopyFile ? "Copy" : "Link", source: src, destination: dst)
             }
 
             guard delegate.shouldPerformOnItemAtPath(src, to: dst) else { return }

Sources/FoundationEssentials/String/String+Internals.swift

@@ -23,7 +23,12 @@ import Darwin
 import WinSDK
 
 extension String {
-    package func withNTPathRepresentation<Result>(_ body: (UnsafePointer<WCHAR>) throws -> Result) throws -> Result {
+    /// Invokes `body` with a resolved and potentially `\\?\`-prefixed version of the pointee,
+    /// to ensure long paths greater than MAX_PATH (260) characters are handled correctly.
+    ///
+    /// - parameter relative: Returns the original path without transforming through GetFullPathNameW + PathCchCanonicalizeEx, if the path is relative.
+    /// - seealso: https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
+    package func withNTPathRepresentation<Result>(relative: Bool = false, _ body: (UnsafePointer<WCHAR>) throws -> Result) throws -> Result {
         guard !isEmpty else {
             throw CocoaError.errorWithFilePath(.fileReadInvalidFileName, "")
         }
@@ -35,15 +40,42 @@ extension String {
         // leading slash indicates a rooted path on the drive for the current
         // working directory.
         return try Substring(self.utf8.dropFirst(bLeadingSlash ? 1 : 0)).withCString(encodedAs: UTF16.self) { pwszPath in
+            if relative && PathIsRelativeW(pwszPath) {
+                return try body(pwszPath)
+            }
+
             // 1. Normalize the path first.
+            // Contrary to the documentation, this works on long paths independently
+            // of the registry or process setting to enable long paths (but it will also
+            // not add the \\?\ prefix required by other functions under these conditions).
             let dwLength: DWORD = GetFullPathNameW(pwszPath, 0, nil, nil)
-            return try withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: Int(dwLength)) {
-                guard GetFullPathNameW(pwszPath, DWORD($0.count), $0.baseAddress, nil) > 0 else {
+            return try withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: Int(dwLength)) { pwszFullPath in
+                guard (1..<dwLength).contains(GetFullPathNameW(pwszPath, DWORD(pwszFullPath.count), pwszFullPath.baseAddress, nil)) else {
                     throw CocoaError.errorWithFilePath(self, win32: GetLastError(), reading: true)
                 }
 
-                // 2. Perform the operation on the normalized path.
-                return try body($0.baseAddress!)
+                // 1.5 Leave \\.\ prefixed paths alone since device paths are already an exact representation and PathCchCanonicalizeEx will mangle these.
+                if let base = pwszFullPath.baseAddress,
+                    base[0] == UInt16(UInt8._backslash),
+                    base[1] == UInt16(UInt8._backslash),
+                    base[2] == UInt16(UInt8._period),
+                    base[3] == UInt16(UInt8._backslash) {
+                    return try body(base)
+                }
+
+                // 2. Canonicalize the path.
+                // This will add the \\?\ prefix if needed based on the path's length.
+                var pwszCanonicalPath: LPWSTR?
+                let flags: ULONG = PATHCCH_ALLOW_LONG_PATHS
+                let result = PathAllocCanonicalize(pwszFullPath.baseAddress, flags, &pwszCanonicalPath)
+                if let pwszCanonicalPath {
+                    defer { LocalFree(pwszCanonicalPath) }
+                    if result == S_OK {
+                        // 3. Perform the operation on the normalized path.
+                        return try body(pwszCanonicalPath)
+                    }
+                }
+                throw CocoaError.errorWithFilePath(self, win32: WIN32_FROM_HRESULT(result), reading: true)
             }
         }
     }

Sources/FoundationEssentials/URL/URL.swift

@@ -690,18 +690,6 @@ public struct URL: Equatable, Sendable, Hashable {
     ///
     /// Returns `nil` if a `URL` cannot be formed with the string (for example, if the string contains characters that are illegal in a URL, or is an empty string).
     public init?(string: __shared String, relativeTo url: __shared URL?) {
-        #if os(Linux)
-        // Workaround for a Linux-only crash where swift-corelibs-foundation's
-        // NSURL.baseURL.getter returns a value of 0x1 when bridging to URL.
-        // Crash doesn't occur when swift-corelibs-foundation is rebuilt with
-        // the new swift-foundation URL code, so this is temporary to get
-        // swift-foundation CI to pass.
-        if unsafeBitCast(url, to: (UnsafeRawPointer, UnsafeRawPointer).self) == (UnsafeRawPointer(bitPattern: 0x1), UnsafeRawPointer(bitPattern: 0x0)) {
-            guard let inner = URL._type.init(string: string, relativeTo: nil) else { return nil }
-            _url = inner.convertingFileReference()
-            return
-        }
-        #endif
         guard let inner = URL._type.init(string: string, relativeTo: url) else { return nil }
         _url = inner.convertingFileReference()
     }

Sources/FoundationEssentials/URL/URLParser.swift

@@ -435,41 +435,6 @@ internal struct RFC3986Parser {
         return validate(string: password, component: .password, percentEncodingAllowed: percentEncodingAllowed)
     }
 
-    private static func isIPvFuture(_ innerHost: some StringProtocol) -> Bool {
-        // precondition: IP-literal == "[" innerHost [ "%25" zoneID ] "]"
-        var iter = innerHost.utf8.makeIterator()
-        guard iter.next() == UInt8(ascii: "v") else { return false }
-        guard let second = iter.next(), second.isValidHexDigit else { return false }
-        while let next = iter.next() {
-            if next.isValidHexDigit { continue }
-            if next == ._dot { return true }
-            return false
-        }
-        return false
-    }
-
-    /// Only checks that the characters are allowed in an IPv6 address.
-    /// Does not validate the format of the IPv6 address.
-    private static func validateIPv6Address(_ address: some StringProtocol) -> Bool {
-        let isValid = address.utf8.withContiguousStorageIfAvailable {
-            $0.allSatisfy { $0.isValidHexDigit || $0 == UInt8(ascii: ":") || $0 == UInt8(ascii: ".") }
-        }
-        if let isValid {
-            return isValid
-        }
-        #if FOUNDATION_FRAMEWORK
-        if let fastCharacters = address._ns._fastCharacterContents() {
-            let charsBuffer = UnsafeBufferPointer(start: fastCharacters, count: address._ns.length)
-            return charsBuffer.allSatisfy {
-                guard $0 < 128 else { return false }
-                let v = UInt8($0)
-                return v.isValidHexDigit || v == UInt8(ascii: ":") || v == UInt8(ascii: ".")
-            }
-        }
-        #endif
-        return address.utf8.allSatisfy { $0.isValidHexDigit || $0 == UInt8(ascii: ":") || $0 == UInt8(ascii: ".") }
-    }
-
     /// Validates an IP-literal host string that has leading and trailing brackets.
     /// If the host string contains a zone ID delimiter "%", this must be percent encoded to "%25" to be valid.
     /// The zone ID may contain any `reg_name` characters, including percent-encoding.
@@ -483,11 +448,7 @@ internal struct RFC3986Parser {
 
         guard let percentIndex = utf8.firstIndex(of: UInt8(ascii: "%")) else {
             // There is no zoneID, so the whole innerHost must be the IP-literal address.
-            if isIPvFuture(innerHost) {
-                return validate(string: innerHost, component: .hostIPvFuture, percentEncodingAllowed: false)
-            } else {
-                return validateIPv6Address(innerHost)
-            }
+            return validate(string: innerHost, component: .hostIPvFuture, percentEncodingAllowed: false)
         }
 
         // The first "%" in an IP-literal must be the zone ID delimiter.
@@ -503,11 +464,7 @@ internal struct RFC3986Parser {
             return false
         }
 
-        if isIPvFuture(innerHost) {
-            return validate(string: innerHost[..<percentIndex], component: .hostIPvFuture, percentEncodingAllowed: false) && validate(string: innerHost[innerHost.index(after: twoAfterIndex)...], component: .hostZoneID)
-        } else {
-            return validateIPv6Address(innerHost[..<percentIndex]) && validate(string: innerHost[innerHost.index(after: twoAfterIndex)...], component: .hostZoneID)
-        }
+        return validate(string: innerHost[..<percentIndex], component: .hostIPvFuture, percentEncodingAllowed: false) && validate(string: innerHost[innerHost.index(after: twoAfterIndex)...], component: .hostZoneID)
     }
 
     private static func validate(host: some StringProtocol, knownIPLiteral: Bool = false) -> Bool {

Sources/FoundationEssentials/URL/URLTemplate.swift

@@ -130,7 +130,7 @@ extension URL {
 }
 
 // MARK: - Parse
-
+#if FOUNDATION_FRAMEWORK
 extension URL.Template {
     /// Creates a new template from its text form.
     ///
@@ -164,6 +164,7 @@ extension URL.Template {
         }
     }
 }
+#endif
 
 // MARK: -
 

Sources/FoundationEssentials/URL/URLTemplate_Expression.swift

@@ -10,7 +10,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if FOUNDATION_FRAMEWORK
 internal import RegexBuilder
+#endif
+
 #if canImport(CollectionsInternal)
 internal import CollectionsInternal
 #elseif canImport(OrderedCollections)
@@ -79,6 +82,7 @@ extension URL.Template.Expression.Element: CustomStringConvertible {
     }
 }
 
+#if FOUNDATION_FRAMEWORK
 extension URL.Template.Expression {
     init(_ input: String) throws {
         var remainder = input[...]
@@ -202,6 +206,7 @@ extension URL.Template {
         }
     }
 }
+#endif
 
 // .------------------------------------------------------------------.
 // |          NUL     +      .       /       ;      ?      &      #   |