Sync latest TSC changes from master (#2952)

Author: neonichu

swift-tools-support-core/.gitignore

@@ -5,3 +5,4 @@
 xcuserdata/
 .swiftpm
 build
+.vscode

swift-tools-support-core/CODEOWNERS

@@ -0,0 +1,27 @@
+# This file is a list of the people responsible for ensuring that patches for a
+# particular part of Swift are reviewed, either by themselves or by someone else.
+# They are also the gatekeepers for their part of Swift, with the final word on
+# what goes in or not.
+# 
+# The list is sorted by surname and formatted to allow easy grepping and
+# beautification by scripts.  The fields are: name (N), email (E), web-address
+# (W), PGP key ID and fingerprint (P), description (D), and snail-mail address
+# (S).
+ 
+# N: Ankit Aggarwal
+# E: [email protected]
+# D: Package Manager
+# 
+# N: Anders Bertelrud
+# E: [email protected]
+# D: Package Manager
+ 
+# N: Daniel Dunbar
+# E: [email protected]
+# D: Package Manager
+
+###
+
+# The following lines are used by GitHub to automatically recommend reviewers.
+
+* @aciidb0mb3r @abertelrud @neonichu @friedbunny

swift-tools-support-core/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.1
+// swift-tools-version:5.2
 
 /*
  This source file is part of the Swift.org open source project
@@ -83,3 +83,16 @@ let package = Package(
             dependencies: ["TSCUtility", "TSCTestSupport", "TSCTestSupportExecutable"]),
     ]
 )
+
+// FIXME: conditionalise these flags since SwiftPM 5.3 and earlier will crash
+// for platforms they don't know about.
+#if os(Windows)
+  if let TSCBasic = package.targets.first(where: { $0.name == "TSCBasic" }) {
+    TSCBasic.cxxSettings = [
+      .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])),
+    ]
+    TSCBasic.linkerSettings = [
+      .linkedLibrary("Pathcch", .when(platforms: [.windows])),
+    ]
+  }
+#endif

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

@@ -21,7 +21,7 @@ import Foundation
 /// strings, we wish to retain the flexibility to micro-optimize the memory
 /// allocation of the storage (for example, by inlining the storage for small
 /// strings or and by eliminating wasted space in growable arrays). For
-/// construction of byte arrays, clients should use the `OutputByteStream` class
+/// construction of byte arrays, clients should use the `WritableByteStream` class
 /// and then convert to a `ByteString` when complete.
 public struct ByteString: ExpressibleByArrayLiteral, Hashable {
     /// The buffer contents.
@@ -142,7 +142,7 @@ extension ByteString: CustomStringConvertible {
 /// ByteStreamable conformance for a ByteString.
 extension ByteString: ByteStreamable {
     @inlinable
-    public func write(to stream: OutputByteStream) {
+    public func write(to stream: WritableByteStream) {
         stream.write(_bytes)
     }
 }

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

@@ -33,7 +33,7 @@ add_library(TSCBasic
   ObjectIdentifierProtocol.swift
   OrderedDictionary.swift
   OrderedSet.swift
-  OutputByteStream.swift
+  WritableByteStream.swift
   Path.swift
   PathShims.swift
   Process.swift
@@ -60,12 +60,14 @@ if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
   target_link_libraries(TSCBasic PUBLIC
     Foundation)
 endif()
+target_link_libraries(TSCBasic PRIVATE
+  $<$<PLATFORM_ID:Windows>:Pathcch>)
 # NOTE(compnerd) workaround for CMake not setting up include flags yet
 set_target_properties(TSCBasic PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
 
 
-if(USE_CMAKE_INSTALL)
+if(CMAKE_SYSTEM_NAME STREQUAL Windows)
 install(TARGETS TSCBasic
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib

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

@@ -230,7 +230,7 @@ public extension FileSystem {
     }
 
     /// Write to a file from a stream producer.
-    func writeFileContents(_ path: AbsolutePath, body: (OutputByteStream) -> Void) throws {
+    func writeFileContents(_ path: AbsolutePath, body: (WritableByteStream) -> Void) throws {
         let contents = BufferedOutputByteStream()
         body(contents)
         try createDirectory(path.parentDirectory, recursive: true)
@@ -281,7 +281,19 @@ private class LocalFileSystem: FileSystem {
 
     var currentWorkingDirectory: AbsolutePath? {
         let cwdStr = FileManager.default.currentDirectoryPath
+
+#if _runtime(_ObjC)
+        // The ObjC runtime indicates that the underlying Foundation has ObjC
+        // interoperability in which case the return type of
+        // `fileSystemRepresentation` is different from the Swift implementation
+        // of Foundation.
         return try? AbsolutePath(validating: cwdStr)
+#else
+        let fsr: UnsafePointer<Int8> = cwdStr.fileSystemRepresentation
+        defer { fsr.deallocate() }
+
+        return try? AbsolutePath(validating: String(cString: fsr))
+#endif
     }
 
     func changeCurrentWorkingDirectory(to path: AbsolutePath) throws {

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

@@ -58,45 +58,44 @@ public func transitiveClosure<T>(
 public func topologicalSort<T: Hashable>(
     _ nodes: [T], successors: (T) throws -> [T]
 ) throws -> [T] {
-    // Stack represented as stackframes consisting from node-successors key-value pairs that
-    // are being traversed.
-    var stack: OrderedDictionary<T, ArraySlice<T>> = [:]
-    // A set of already visited.
-    var visited: Set<T> = []
-    var result: [T] = []
-    
-    // Implements a topological sort via iteration and reverse postorder DFS.
-    for node in nodes {
-        guard visited.insert(node).inserted else { continue }
-        stack[node] = try successors(node).dropFirst(0)
-        
-        // Peek the top of the stack
-        while let (node, children) = stack.last {
-            // Take the next successor for the given node.
-            if let succ = children.first {
-                // Drop the first successor from the children list and update the stack frame
-                stack[node] = children.dropFirst()
-                
-                if let _ = stack[succ] {
-                    // If the successor is already in this current stack, we have found a cycle.
-                    //
-                    // FIXME: We could easily include information on the cycle we found here.
-                    throw GraphError.unexpectedCycle
-                }
-                // Mark this node as visited -- we are done if it already was.
-                guard visited.insert(succ).inserted else { continue }
-                // Push it to the top of the stack
-                stack[succ] = try successors(succ).dropFirst(0)
-            } else {
-                // Pop the node from the stack if all successors traversed.
-                stack.removeValue(forKey: node)
-                // Add to the result.
-                result.append(node)
+    // Implements a topological sort via recursion and reverse postorder DFS.
+    func visit(_ node: T,
+               _ stack: inout OrderedSet<T>, _ visited: inout Set<T>, _ result: inout [T],
+               _ successors: (T) throws -> [T]) throws {
+        // Mark this node as visited -- we are done if it already was.
+        if !visited.insert(node).inserted {
+            return
+        }
+
+        // Otherwise, visit each adjacent node.
+        for succ in try successors(node) {
+            guard stack.append(succ) else {
+                // If the successor is already in this current stack, we have found a cycle.
+                //
+                // FIXME: We could easily include information on the cycle we found here.
+                throw GraphError.unexpectedCycle
             }
+            try visit(succ, &stack, &visited, &result, successors)
+            let popped = stack.removeLast()
+            assert(popped == succ)
         }
+
+        // Add to the result.
+        result.append(node)
     }
-    // Make sure we popped all of the stack frames.
-    assert(stack.isEmpty)
+
+    // FIXME: This should use a stack not recursion.
+    var visited = Set<T>()
+    var result = [T]()
+    var stack = OrderedSet<T>()
+    for node in nodes {
+        precondition(stack.isEmpty)
+        stack.append(node)
+        try visit(node, &stack, &visited, &result, successors)
+        let popped = stack.removeLast()
+        assert(popped == node)
+    }
+
     return result.reversed()
 }
 
@@ -114,41 +113,34 @@ public func findCycle<T: Hashable>(
     _ nodes: [T],
     successors: (T) throws -> [T]
 ) rethrows -> (path: [T], cycle: [T])? {
-    // Stack represented as stackframes consisting from node-successors key-value pairs that
-    // are being traversed.
-    var stack: OrderedDictionary<T, ArraySlice<T>> = [:]
-    // A set of already visited
-    var visited: Set<T> = []
-    
-    for node in nodes {
-        guard visited.insert(node).inserted else { continue }
-        stack[node] = try successors(node).dropFirst(0)
-        
-        // Peek the top of the stack
-        while let (node, children) = stack.last {
-            // Take the next successor for the given node.
-            if let succ = children.first {
-                // Drop the first successor from the children list and update the stack frame
-                stack[node] = children.dropFirst()
-                
-                if let _ = stack[succ] {
-                    let index = stack.firstIndex { $0.key == succ }!
-                    return (
-                        Array(stack[stack.startIndex..<index]).map { $0.key },
-                        Array(stack[index..<stack.endIndex]).map { $0.key })
-                }
-                // Mark this node as visited -- we are done if it already was.
-                guard visited.insert(succ).inserted else { continue }
-                // Push it to the top of the stack
-                stack[succ] = try successors(succ).dropFirst(0)
-            } else {
-                // Pop the node from the stack if all successors traversed.
-                stack.removeValue(forKey: node)
+    // Ordered set to hold the current traversed path.
+    var path = OrderedSet<T>()
+
+    // Function to visit nodes recursively.
+    // FIXME: Convert to stack.
+    func visit(_ node: T, _ successors: (T) throws -> [T]) rethrows -> (path: [T], cycle: [T])? {
+        // If this node is already in the current path then we have found a cycle.
+        if !path.append(node) {
+            let index = path.firstIndex(of: node)!
+            return (Array(path[path.startIndex..<index]), Array(path[index..<path.endIndex]))
+        }
+
+        for succ in try successors(node) {
+            if let cycle = try visit(succ, successors) {
+                return cycle
             }
         }
+        // No cycle found for this node, remove it from the path.
+        let item = path.removeLast()
+        assert(item == node)
+        return nil
+    }
+
+    for node in nodes {
+        if let cycle = try visit(node, successors) {
+            return cycle
+        }
     }
-    // Make sure we popped all of the stack frames.
-    assert(stack.isEmpty)
     // Couldn't find any cycle in the graph.
     return nil
 }

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

@@ -115,11 +115,11 @@ extension JSON {
 
 /// Support writing to a byte stream.
 extension JSON: ByteStreamable {
-    public func write(to stream: OutputByteStream) {
+    public func write(to stream: WritableByteStream) {
         write(to: stream, indent: nil)
     }
 
-    public func write(to stream: OutputByteStream, indent: Int?) {
+    public func write(to stream: WritableByteStream, indent: Int?) {
         func indentStreamable(offset: Int? = nil) -> ByteStreamable {
             return Format.asRepeating(string: " ", count: indent.flatMap({ $0 + (offset ?? 0) }) ?? 0)
         }