Merge pull request #3009 from abertelrud/vendor-latest-tools-support-core

Sync latest TSC changes from `main`

Author: shahmishal

swift-tools-support-core/.swiftformat

@@ -0,0 +1,13 @@
+# file options
+
+--swiftversion 5.0
+--exclude .build
+
+# format options
+
+--self insert
+--patternlet inline
+--stripunusedargs unnamed-only
+--ifdef no-indent
+
+# rules

swift-tools-support-core/Sources/TSCBasic/ByteString.swift

@@ -108,11 +108,7 @@ public struct ByteString: ExpressibleByArrayLiteral, Hashable {
 extension ByteString: CustomStringConvertible {
     /// Return the string decoded as a UTF8 sequence, or traps if not possible.
     public var description: String {
-        guard let description = validDescription else {
-            fatalError("invalid byte string: \(cString)")
-        }
-
-        return description
+        return cString
     }
 
     /// Return the string decoded as a UTF8 sequence, if possible.

swift-tools-support-core/Sources/TSCBasic/CMakeLists.txt

@@ -49,6 +49,7 @@ add_library(TSCBasic
   Thread.swift
   Tuple.swift
   misc.swift)
+  
 target_compile_options(TSCBasic PUBLIC
   # Don't use GNU strerror_r on Android.
   "$<$<PLATFORM_ID:Android>:SHELL:-Xcc -U_GNU_SOURCE>"
@@ -57,8 +58,10 @@ target_compile_options(TSCBasic PUBLIC
 target_link_libraries(TSCBasic PUBLIC
   TSCLibc)
 if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
-  target_link_libraries(TSCBasic PUBLIC
-    Foundation)
+  if(Foundation_FOUND)
+    target_link_libraries(TSCBasic PUBLIC
+      Foundation)
+  endif()
 endif()
 target_link_libraries(TSCBasic PRIVATE
   $<$<PLATFORM_ID:Windows>:Pathcch>)

swift-tools-support-core/Sources/TSCBasic/FileSystem.swift

@@ -10,6 +10,7 @@
 
 import TSCLibc
 import Foundation
+import Dispatch
 
 public enum FileSystemError: Swift.Error {
     /// Access to the path is denied.
@@ -200,6 +201,9 @@ public protocol FileSystem: class {
 
     /// Move a file or directory.
     func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws
+
+    /// Execute the given block while holding the lock.
+    func withLock<T>(on path: AbsolutePath, type: FileLock.LockType, _ body: () throws -> T) throws -> T
 }
 
 /// Convenience implementations (default arguments aren't permitted in protocol
@@ -240,6 +244,10 @@ public extension FileSystem {
     func getFileInfo(_ path: AbsolutePath) throws -> FileInfo {
         throw FileSystemError.unsupported
     }
+
+    func withLock<T>(on path: AbsolutePath, type: FileLock.LockType, _ body: () throws -> T) throws -> T {
+        throw FileSystemError.unsupported
+    }
 }
 
 /// Concrete FileSystem implementation which communicates with the local file system.
@@ -450,6 +458,11 @@ private class LocalFileSystem: FileSystem {
         guard !exists(destinationPath) else { throw FileSystemError.alreadyExistsAtDestination }
         try FileManager.default.moveItem(at: sourcePath.asURL, to: destinationPath.asURL)
     }
+
+    func withLock<T>(on path: AbsolutePath, type: FileLock.LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        let lock = FileLock(name: path.basename, cachePath: path.parentDirectory)
+        return try lock.withLock(type: type, body)
+    }
 }
 
 // FIXME: This class does not yet support concurrent mutation safely.
@@ -499,9 +512,21 @@ public class InMemoryFileSystem: FileSystem {
             return contents
         }
     }
+    // Used to ensure that DispatchQueues are releassed when they are no longer in use.
+    private struct WeakReference<Value: AnyObject> {
+        weak var reference: Value?
+
+        init(_ value: Value?) {
+            self.reference = value
+        }
+    }
 
     /// The root filesytem.
     private var root: Node
+    /// A map that keeps weak references to all locked files.
+    private var lockFiles = Dictionary<AbsolutePath, WeakReference<DispatchQueue>>()
+    /// Used to access lockFiles in a thread safe manner.
+    private let lockFilesLock = Lock()
 
     public init() {
         root = Node(.directory(DirectoryContents()))
@@ -760,6 +785,21 @@ public class InMemoryFileSystem: FileSystem {
 
         contents.entries[sourcePath.basename] = nil
     }
+
+    public func withLock<T>(on path: AbsolutePath, type: FileLock.LockType = .exclusive, _ body: () throws -> T) throws -> T {
+
+        let fileQueue: DispatchQueue = lockFilesLock.withLock {
+            if let queueReference = lockFiles[path], let queue = queueReference.reference {
+                return queue
+            } else {
+                let queue = DispatchQueue(label: "org.swift.swiftpm.in-memory-file-system.file-queue", attributes: .concurrent)
+                lockFiles[path] = WeakReference(queue)
+                return queue
+            }
+        }
+
+        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init() , execute: body)
+    }
 }
 
 /// A rerooted view on an existing FileSystem.
@@ -864,6 +904,10 @@ public class RerootedFileSystemView: FileSystem {
     public func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
         try underlyingFileSystem.move(from: formUnderlyingPath(sourcePath), to: formUnderlyingPath(sourcePath))
     }
+
+    public func withLock<T>(on path: AbsolutePath, type: FileLock.LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        return try underlyingFileSystem.withLock(on: formUnderlyingPath(path), type: type, body)
+    }
 }
 
 /// Public access to the local FS proxy.

swift-tools-support-core/Sources/TSCBasic/HashAlgorithms.swift

@@ -174,7 +174,7 @@ public struct SHA256: HashAlgorithm {
 }
 
 /// Wraps CryptoKit.SHA256 to provide a HashAlgorithm conformance to it.
-@available(macOS 10.15, *)
+@available(macOS 10.15, iOS 13, *)
 public struct CryptoKitSHA256: HashAlgorithm {
     public init() {
     }

swift-tools-support-core/Sources/TSCBasic/Lock.swift

@@ -19,10 +19,18 @@ public struct Lock {
     public init() {
     }
 
+    func lock() {
+        _lock.lock()
+    }
+
+    func unlock() {
+        _lock.unlock()
+    }
+
     /// Execute the given block while holding the lock.
     public func withLock<T> (_ body: () throws -> T) rethrows -> T {
-        _lock.lock()
-        defer { _lock.unlock() }
+        lock()
+        defer { unlock() }
         return try body()
     }
 }
@@ -35,6 +43,12 @@ enum ProcessLockError: Swift.Error {
 /// It can be used for things like serializing concurrent mutations on a shared resource
 /// by mutiple instances of a process. The `FileLock` is not thread-safe.
 public final class FileLock {
+
+    public enum LockType {
+        case exclusive
+        case shared
+    }
+
     /// File descriptor to the lock file.
   #if os(Windows)
     private var handle: HANDLE?
@@ -56,14 +70,14 @@ public final class FileLock {
     /// Try to aquire a lock. This method will block until lock the already aquired by other process.
     ///
     /// Note: This method can throw if underlying POSIX methods fail.
-    public func lock() throws {
+    public func lock(type: LockType = .exclusive) throws {
       #if os(Windows)
         if handle == nil {
-            let h = lockFile.pathString.withCString(encodedAs: UTF16.self, {
+            let h: HANDLE = lockFile.pathString.withCString(encodedAs: UTF16.self, {
                 CreateFileW(
                     $0,
                     UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE),
-                    0,
+                    UInt32(FILE_SHARE_READ) | UInt32(FILE_SHARE_WRITE),
                     nil,
                     DWORD(OPEN_ALWAYS),
                     DWORD(FILE_ATTRIBUTE_NORMAL),
@@ -79,9 +93,17 @@ public final class FileLock {
         overlapped.Offset = 0
         overlapped.OffsetHigh = 0
         overlapped.hEvent = nil
-        if !LockFileEx(handle, DWORD(LOCKFILE_EXCLUSIVE_LOCK), 0,
-                       DWORD(INT_MAX), DWORD(INT_MAX), &overlapped) {
-            throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError()))
+        switch type {
+        case .exclusive:
+            if !LockFileEx(handle, DWORD(LOCKFILE_EXCLUSIVE_LOCK), 0,
+                           DWORD(INT_MAX), DWORD(INT_MAX), &overlapped) {
+                throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError()))
+            }
+        case .shared:
+            if !LockFileEx(handle, 0, 0,
+                           DWORD(INT_MAX), DWORD(INT_MAX), &overlapped) {
+                throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError()))
+            }
         }
       #else
         // Open the lock file.
@@ -94,7 +116,9 @@ public final class FileLock {
         }
         // Aquire lock on the file.
         while true {
-            if flock(fileDescriptor!, LOCK_EX) == 0 {
+            if type == .exclusive && flock(fileDescriptor!, LOCK_EX) == 0 {
+                break
+            } else if type == .shared && flock(fileDescriptor!, LOCK_SH) == 0 {
                 break
             }
             // Retry if interrupted.
@@ -129,8 +153,8 @@ public final class FileLock {
     }
 
     /// Execute the given block while holding the lock.
-    public func withLock<T>(_ body: () throws -> T) throws -> T {
-        try lock()
+    public func withLock<T>(type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        try lock(type: type)
         defer { unlock() }
         return try body()
     }

swift-tools-support-core/Sources/TSCBasic/PathShims.swift

@@ -23,10 +23,13 @@ import Foundation
 /// Returns the "real path" corresponding to `path` by resolving any symbolic links.
 public func resolveSymlinks(_ path: AbsolutePath) -> AbsolutePath {
 #if os(Windows)
-    do {
-        return try AbsolutePath(FileManager.default.destinationOfSymbolicLink(atPath: path.pathString).standardizingPath)
-    } catch {
-        return AbsolutePath(path.pathString.standardizingPath)
+    var resolved: URL = URL(fileURLWithPath: path.pathString)
+    if let destination = try? FileManager.default.destinationOfSymbolicLink(atPath: path.pathString) {
+        resolved = URL(fileURLWithPath: destination, relativeTo: URL(fileURLWithPath: path.pathString))
+    }
+
+    return resolved.standardized.withUnsafeFileSystemRepresentation {
+        try! AbsolutePath(validating: String(cString: $0!))
     }
 #else
     let pathStr = path.pathString

swift-tools-support-core/Sources/TSCBasic/TerminalController.swift

@@ -10,7 +10,7 @@
 
 import TSCLibc
 #if os(Windows)
-import MSVCRT
+import CRT
 #endif
 
 /// A class to have better control on tty output streams: standard output and standard error.

swift-tools-support-core/Sources/TSCBasic/Thread.swift

@@ -9,6 +9,9 @@
 */
 
 import Foundation
+#if os(Windows)
+import WinSDK
+#endif
 
 /// This class bridges the gap between Darwin and Linux Foundation Threading API.
 /// It provides closure based execution and a join method to block the calling thread
@@ -64,6 +67,15 @@ final public class Thread {
             }
         }
     }
+
+    /// Causes the calling thread to yield execution to another thread.
+    public static func yield() {
+        #if os(Windows)
+          SwitchToThread()
+        #else
+          sched_yield()
+        #endif
+    }
 }
 
 #if canImport(Darwin)

swift-tools-support-core/Sources/TSCLibc/libc.swift

@@ -11,7 +11,7 @@
 #if canImport(Glibc)
 @_exported import Glibc
 #elseif os(Windows)
-@_exported import MSVCRT
+@_exported import CRT
 @_exported import WinSDK
 #else
 @_exported import Darwin.C

swift-tools-support-core/Sources/TSCTestSupport/misc.swift

@@ -25,27 +25,21 @@ public enum Configuration {
 }
 
 /// Test helper utility for executing a block with a temporary directory.
-public func mktmpdir(
+public func testWithTemporaryDirectory(
     function: StaticString = #function,
-    file: StaticString = #file,
-    line: UInt = #line,
     body: (AbsolutePath) throws -> Void
-) {
-    do {
-        let cleanedFunction = function.description
-            .replacingOccurrences(of: "(", with: "")
-            .replacingOccurrences(of: ")", with: "")
-            .replacingOccurrences(of: ".", with: "")
-        try withTemporaryDirectory(prefix: "spm-tests-\(cleanedFunction)") { tmpDirPath in
-            defer {
-                // Unblock and remove the tmp dir on deinit.
-                try? localFileSystem.chmod(.userWritable, path: tmpDirPath, options: [.recursive])
-                try? localFileSystem.removeFileTree(tmpDirPath)
-            }
-            try body(tmpDirPath)
+) throws {
+    let cleanedFunction = function.description
+        .replacingOccurrences(of: "(", with: "")
+        .replacingOccurrences(of: ")", with: "")
+        .replacingOccurrences(of: ".", with: "")
+    try withTemporaryDirectory(prefix: "spm-tests-\(cleanedFunction)") { tmpDirPath in
+        defer {
+            // Unblock and remove the tmp dir on deinit.
+            try? localFileSystem.chmod(.userWritable, path: tmpDirPath, options: [.recursive])
+            try? localFileSystem.removeFileTree(tmpDirPath)
         }
-    } catch {
-        XCTFail("\(error)", file: file, line: line)
+        try body(tmpDirPath)
     }
 }
 

swift-tools-support-core/Sources/TSCUtility/Bits.swift

@@ -84,6 +84,15 @@ struct Bits: RandomAccessCollection {
       return buffer.buffer.dropFirst(offset >> 3).prefix((newOffset - offset) >> 3)
     }
 
+    mutating func skip(bytes count: Int) throws {
+      precondition(count >= 0)
+      precondition(offset & 0b111 == 0)
+      let newOffset = offset &+ (count << 3)
+      precondition(newOffset >= offset)
+      if newOffset > buffer.count { throw Error.bufferOverflow }
+      offset = newOffset
+    }
+
     mutating func advance(toBitAlignment align: Int) throws {
       precondition(align > 0)
       precondition(offset &+ (align&-1) >= offset)