Merge pull request #2 from apple/update

Sync with SwiftPM trunk

Author: aciidgh

Sources/TSCBasic/Await.swift

@@ -15,7 +15,7 @@
 /// - Returns: The value wrapped by the async method's result.
 /// - Throws: The error wrapped by the async method's result
 public func await<T, ErrorType>(_ body: (@escaping (Result<T, ErrorType>) -> Void) -> Void) throws -> T {
-    return try await(body).dematerialize()
+    return try await(body).get()
 }
 
 public func await<T>(_ body: (@escaping (T) -> Void) -> Void) -> T {

Sources/TSCBasic/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(TSCBasic
   Await.swift
   ByteString.swift
   CacheableSequence.swift
+  CodableResult.swift
   CollectionAlgorithms.swift
   CollectionExtensions.swift
   Condition.swift

Sources/TSCBasic/CodableResult.swift

@@ -0,0 +1,62 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2019 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+/// Codable wrapper for Result
+public struct CodableResult<Success, Failure>: Codable where Success: Codable, Failure: Codable & Error {
+    private enum CodingKeys: String, CodingKey {
+        case success, failure
+    }
+    
+    public let result: Result<Success, Failure>
+    public init(result: Result<Success, Failure>) {
+        self.result = result
+    }
+    
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self.result {
+        case .success(let value):
+            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .success)
+            try unkeyedContainer.encode(value)
+        case .failure(let error):
+            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .failure)
+            try unkeyedContainer.encode(error)
+        }
+    }
+
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        guard let key = values.allKeys.first(where: values.contains) else {
+            throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: "Did not find a matching key"))
+        }
+        switch key {
+        case .success:
+            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+            let value = try unkeyedValues.decode(Success.self)
+            self.init(result: .success(value))
+        case .failure:
+            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+            let error = try unkeyedValues.decode(Failure.self)
+            self.init(result: .failure(error))
+        }
+    }
+}
+
+extension CodableResult where Failure == StringError {
+    public init(body: () throws -> Success) {
+        do {
+            self.init(result: .success(try body()))
+        } catch let error as StringError {
+            self.init(result: .failure(error))
+        } catch {
+            self.init(result: .failure(StringError(String(describing: error))))
+        }
+    }
+}

Sources/TSCBasic/Process.swift

@@ -89,12 +89,12 @@ public struct ProcessResult: CustomStringConvertible {
 
     /// Converts stdout output bytes to string, assuming they're UTF8.
     public func utf8Output() throws -> String {
-        return String(decoding: try output.dematerialize(), as: Unicode.UTF8.self)
+        return String(decoding: try output.get(), as: Unicode.UTF8.self)
     }
 
     /// Converts stderr output bytes to string, assuming they're UTF8.
     public func utf8stderrOutput() throws -> String {
-        return String(decoding: try stderrOutput.dematerialize(), as: Unicode.UTF8.self)
+        return String(decoding: try stderrOutput.get(), as: Unicode.UTF8.self)
     }
 
     public var description: String {
@@ -201,10 +201,10 @@ public final class Process: ObjectIdentifierProtocol {
   #endif
 
     /// If redirected, stdout result and reference to the thread reading the output.
-    private var stdout: (result: Result<[UInt8], AnyError>, thread: Thread?) = (Result([]), nil)
+    private var stdout: (result: Result<[UInt8], AnyError>, thread: Thread?) = (.success([]), nil)
 
     /// If redirected, stderr result and reference to the thread reading the output.
-    private var stderr: (result: Result<[UInt8], AnyError>, thread: Thread?) = (Result([]), nil)
+    private var stderr: (result: Result<[UInt8], AnyError>, thread: Thread?) = (.success([]), nil)
 
     /// Queue to protect concurrent reads.
     private let serialQueue = DispatchQueue(label: "org.swift.swiftpm.process")
@@ -516,7 +516,7 @@ public final class Process: ObjectIdentifierProtocol {
         // Close the read end of the output pipe.
         close(fd)
         // Construct the output result.
-        return error.map(Result.init) ?? Result(out)
+        return error.map(Result.init) ?? .success(out)
     }
   #endif
 

Sources/TSCBasic/Result.swift

@@ -1,87 +1,13 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See http://swift.org/LICENSE.txt for license information
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
-/// An simple enum which is either a value or an error.
-/// It can be used for error handling in situations where try catch is
-/// problematic to use, for eg: asynchronous APIs.
-public enum Result<Value, ErrorType: Swift.Error> {
-    /// Indicates success with value in the associated object.
-    case success(Value)
-
-    /// Indicates failure with error inside the associated object.
-    case failure(ErrorType)
-
-    /// Initialiser for value.
-    public init(_ value: Value) {
-        self = .success(value)
-    }
-
-    /// Initialiser for error.
-    public init(_ error: ErrorType) {
-        self = .failure(error)
-    }
-
-    /// Initialise with something that can throw ErrorType.
-    public init(_ body: () throws -> Value) throws {
-        do {
-            self = .success(try body())
-        } catch let error as ErrorType {
-            self = .failure(error)
-        }
-    }
-
-    /// Get the value if success else throw the saved error.
-    public func dematerialize() throws -> Value {
-        switch self {
-        case .success(let value):
-            return value
-        case .failure(let error):
-            throw error
-        }
-    }
-
-    /// Evaluates the given closure when this Result instance has a value.
-    public func map<U>(_ transform: (Value) throws -> U) rethrows -> Result<U, ErrorType> {
-        switch self {
-        case .success(let value):
-            return Result<U, ErrorType>(try transform(value))
-        case .failure(let error):
-            return Result<U, ErrorType>(error)
-        }
-    }
-
-    /// Evaluates the given closure when this Result instance has a value, passing the unwrapped value as a parameter.
-    ///
-    /// The closure returns a Result instance itself which can have value or not.
-    public func flatMap<U>(_ transform: (Value) -> Result<U, ErrorType>) -> Result<U, ErrorType> {
-        switch self {
-            case .success(let value):
-                return transform(value)
-            case .failure(let error):
-                return Result<U, ErrorType>(error)
-        }
-    }
-
-}
-
-extension Result: CustomStringConvertible {
-    public var description: String {
-        switch self {
-        case .success(let value):
-            return "Result(\(value))"
-        case .failure(let error):
-            return "Result(\(error))"
-        }
-    }
-}
-
 /// A type erased error enum.
 public struct AnyError: Swift.Error, CustomStringConvertible {
     /// The underlying error.
@@ -114,9 +40,9 @@ public struct StringError: Equatable, Codable, CustomStringConvertible, Error {
 }
 
 // AnyError specific helpers.
-extension Result where ErrorType == AnyError {
+extension Result where Failure == AnyError {
     /// Initialise with something that throws AnyError.
-    public init(anyError body: () throws -> Value) {
+    public init(anyError body: () throws -> Success) {
         do {
             self = .success(try body())
         } catch {
@@ -132,11 +58,11 @@ extension Result where ErrorType == AnyError {
     /// Evaluates the given throwing closure when this Result instance has a value.
     ///
     /// The final result will either be the transformed value or any error thrown by the closure.
-    public func mapAny<U>(_ transform: (Value) throws -> U) -> Result<U, AnyError> {
+    public func mapAny<U>(_ transform: (Success) throws -> U) -> Result<U, AnyError> {
         switch self {
         case .success(let value):
             do {
-                return Result<U, AnyError>(try transform(value))
+                return Result<U, AnyError>.success(try transform(value))
             } catch {
                 return Result<U, AnyError>(error)
             }
@@ -146,11 +72,11 @@ extension Result where ErrorType == AnyError {
     }
 }
 
-extension Result where ErrorType == StringError {
+extension Result where Failure == StringError {
     /// Create an instance of Result<Value, StringError>.
     ///
     /// Errors will be encoded as StringError using their description.
-    public init(string body: () throws -> Value) {
+    public init(string body: () throws -> Success) {
         do {
             self = .success(try body())
         } catch let error as StringError {
@@ -160,40 +86,3 @@ extension Result where ErrorType == StringError {
         }
     }
 }
-
-extension Result: Equatable where Value: Equatable, ErrorType: Equatable {}
-
-extension Result: Codable where Value: Codable, ErrorType: Codable {
-    private enum CodingKeys: String, CodingKey {
-        case success, failure
-    }
-
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        switch self {
-        case .success(let value):
-            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .success)
-            try unkeyedContainer.encode(value)
-        case .failure(let error):
-            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .failure)
-            try unkeyedContainer.encode(error)
-        }
-    }
-
-    public init(from decoder: Decoder) throws {
-        let values = try decoder.container(keyedBy: CodingKeys.self)
-        guard let key = values.allKeys.first(where: values.contains) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: "Did not find a matching key"))
-        }
-        switch key {
-        case .success:
-            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
-            let value = try unkeyedValues.decode(Value.self)
-            self = .success(value)
-        case .failure:
-            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
-            let error = try unkeyedValues.decode(ErrorType.self)
-            self = .failure(error)
-        }
-    }
-}

Sources/TSCBasic/TemporaryFile.swift

@@ -45,14 +45,23 @@ private extension TempFileError {
 ///
 /// - Returns: Path to directory in which temporary file should be created.
 public func determineTempDirectory(_ dir: AbsolutePath? = nil) throws -> AbsolutePath {
-    // FIXME: Add other platform specific locations.
-    let tmpDir = dir ?? AbsolutePath(NSTemporaryDirectory())
+    let tmpDir = dir ?? cachedTempDirectory
     guard localFileSystem.isDirectory(tmpDir) else {
         throw TempFileError.couldNotFindTmpDir
     }
     return tmpDir
 }
 
+/// Returns temporary directory location by searching relevant env variables.
+///
+/// Evaluates once per execution.
+private var cachedTempDirectory: AbsolutePath = {
+    let override = ProcessEnv.vars["TMPDIR"] ?? ProcessEnv.vars["TEMP"] ?? ProcessEnv.vars["TMP"]
+    if let path = override.flatMap({ try? AbsolutePath(validating: $0) }) {
+        return path
+    }
+    return AbsolutePath(NSTemporaryDirectory())
+}()
 
 /// The closure argument of the `body` closue of `withTemporaryFile`.
 public struct TemporaryFile {
@@ -86,7 +95,7 @@ public struct TemporaryFile {
         // Convert path to a C style string terminating with null char to be an valid input
         // to mkstemps method. The XXXXXX in this string will be replaced by a random string
         // which will be the actual path to the temporary file.
-        var template = [UInt8](path.pathString.utf8).map({ Int8($0) }) + [Int8(0)]
+        var template = Array(path.pathString.utf8CString)
 
         fd = TSCLibc.mkstemps(&template, Int32(suffix.utf8.count))
         // If mkstemps failed then throw error.

Sources/TSCBasic/TerminalController.swift

@@ -9,6 +9,9 @@
 */
 
 import TSCLibc
+#if os(Windows)
+import MSVCRT
+#endif
 
 /// A class to have better control on tty output streams: standard output and standard error.
 /// Allows operations like cursor movement and colored text output on tty.
@@ -84,6 +87,18 @@ public final class TerminalController {
         } else {
             width = 80
         }
+
+#if os(Windows)
+       // Enable VT100 interpretation
+        let hOut = GetStdHandle(STD_OUTPUT_HANDLE)
+        var dwMode: DWORD = 0
+
+        guard hOut != INVALID_HANDLE_VALUE else { return nil }
+        guard GetConsoleMode(hOut, &dwMode) else { return nil }
+
+        dwMode |= DWORD(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+        guard SetConsoleMode(hOut, dwMode) else { return nil }
+#endif
         self.stream = stream
     }
 

Sources/TSCLibc/libc.swift

@@ -17,4 +17,4 @@
 @_exported import Darwin.C
 #endif
 
-@_exported import clibc
+@_exported import TSCclibc

Sources/TSCTestSupport/Product.swift

@@ -97,6 +97,9 @@ extension Product {
         environment["SWIFTPM_TESTS_MODULECACHE"] = self.path.parentDirectory.pathString
         environment["SDKROOT"] = nil
 
+        // Unset the internal env variable that allows skipping certain tests.
+        environment["_SWIFTPM_SKIP_TESTS_LIST"] = nil
+
         var completeArgs = [path.pathString]
         if let packagePath = packagePath {
             completeArgs += ["--package-path", packagePath.pathString]

Sources/TSCUtility/CMakeLists.txt

@@ -18,6 +18,7 @@ add_library(TSCUtility
   IndexStore.swift
   InterruptHandler.swift
   misc.swift
+  OSLog.swift
   PkgConfig.swift
   Platform.swift
   ProgressAnimation.swift