Merge pull request #18 from hartbit/sync-it-up

Sync with SwiftPM trunk

Author: aciidgh

Sources/TSCBasic/Process.swift

@@ -47,11 +47,11 @@ public struct ProcessResult: CustomStringConvertible {
 
     /// The output bytes of the process. Available only if the process was
     /// asked to redirect its output and no stdout output closure was set.
-    public let output: Result<[UInt8], AnyError>
+    public let output: Result<[UInt8], Swift.Error>
 
     /// The output bytes of the process. Available only if the process was
     /// asked to redirect its output and no stderr output closure was set.
-    public let stderrOutput: Result<[UInt8], AnyError>
+    public let stderrOutput: Result<[UInt8], Swift.Error>
 
     /// Create an instance using a POSIX process exit status code and output result.
     ///
@@ -60,8 +60,8 @@ public struct ProcessResult: CustomStringConvertible {
         arguments: [String],
         environment: [String: String],
         exitStatusCode: Int32,
-        output: Result<[UInt8], AnyError>,
-        stderrOutput: Result<[UInt8], AnyError>
+        output: Result<[UInt8], Swift.Error>,
+        stderrOutput: Result<[UInt8], Swift.Error>
     ) {
         let exitStatus: ExitStatus
       #if os(Windows)
@@ -83,8 +83,8 @@ public struct ProcessResult: CustomStringConvertible {
         arguments: [String],
         environment: [String: String],
         exitStatus: ExitStatus,
-        output: Result<[UInt8], AnyError>,
-        stderrOutput: Result<[UInt8], AnyError>
+        output: Result<[UInt8], Swift.Error>,
+        stderrOutput: Result<[UInt8], Swift.Error>
     ) {
         self.arguments = arguments
         self.environment = environment
@@ -207,10 +207,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?) = (.success([]), nil)
+    private var stdout: (result: Result<[UInt8], Swift.Error>, 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?) = (.success([]), nil)
+    private var stderr: (result: Result<[UInt8], Swift.Error>, thread: Thread?) = (.success([]), nil)
 
     /// Queue to protect concurrent reads.
     private let serialQueue = DispatchQueue(label: "org.swift.swiftpm.process")
@@ -449,6 +449,7 @@ public final class Process: ObjectIdentifierProtocol {
 
         let executionResult = ProcessResult(
             arguments: arguments,
+            environment: environment,
             exitStatusCode: p.terminationStatus,
             output: stdout.result,
             stderrOutput: stderr.result
@@ -495,7 +496,7 @@ public final class Process: ObjectIdentifierProtocol {
     /// Reads the given fd and returns its result.
     ///
     /// Closes the fd before returning.
-    private func readOutput(onFD fd: Int32, outputClosure: OutputClosure?) -> Result<[UInt8], AnyError> {
+    private func readOutput(onFD fd: Int32, outputClosure: OutputClosure?) -> Result<[UInt8], Swift.Error> {
         // Read all of the data from the output pipe.
         let N = 4096
         var buf = [UInt8](repeating: 0, count: N + 1)
@@ -526,7 +527,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) ?? .success(out)
+        return error.map(Result.failure) ?? .success(out)
     }
   #endif
 

Sources/TSCBasic/Result.swift

@@ -8,22 +8,13 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
-/// A type erased error enum.
-public struct AnyError: Swift.Error, CustomStringConvertible {
-    /// The underlying error.
-    public let underlyingError: Swift.Error
-
-    public init(_ error: Swift.Error) {
-        // If we already have any error, don't nest it.
-        if case let error as AnyError = error {
-            self = error
-        } else {
-            self.underlyingError = error
-        }
-    }
-
-    public var description: String {
-        return String(describing: underlyingError)
+extension Result where Failure == Error {
+    public func tryMap<NewSuccess>(_ closure: (Success) throws -> NewSuccess) -> Result<NewSuccess, Error> {
+        flatMap({ value in
+            Result<NewSuccess, Error>(catching: {
+                try closure(value)
+            })
+        })
     }
 }
 
@@ -39,39 +30,6 @@ public struct StringError: Equatable, Codable, CustomStringConvertible, Error {
     }
 }
 
-// AnyError specific helpers.
-extension Result where Failure == AnyError {
-    /// Initialise with something that throws AnyError.
-    public init(anyError body: () throws -> Success) {
-        do {
-            self = .success(try body())
-        } catch {
-            self = .failure(AnyError(error))
-        }
-    }
-
-    /// Initialise with an error, it will be automatically converted to AnyError.
-    public init(_ error: Swift.Error) {
-        self = .failure(AnyError(error))
-    }
-
-    /// 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: (Success) throws -> U) -> Result<U, AnyError> {
-        switch self {
-        case .success(let value):
-            do {
-                return Result<U, AnyError>.success(try transform(value))
-            } catch {
-                return Result<U, AnyError>(error)
-            }
-        case .failure(let error):
-            return Result<U, AnyError>(error)
-        }
-    }
-}
-
 extension Result where Failure == StringError {
     /// Create an instance of Result<Value, StringError>.
     ///

Tests/TSCBasicTests/AwaitTests.swift

@@ -19,15 +19,15 @@ class AwaitTests: XCTestCase {
         case error
     }
 
-    func async(_ param: String, _ completion: @escaping (Result<String, AnyError>) -> Void) {
+    func async(_ param: String, _ completion: @escaping (Result<String, Error>) -> Void) {
         DispatchQueue.global().async {
             completion(.success(param))
         }
     }
 
-    func throwingAsync(_ param: String, _ completion: @escaping (Result<String, AnyError>) -> Void) {
+    func throwingAsync(_ param: String, _ completion: @escaping (Result<String, Error>) -> Void) {
         DispatchQueue.global().async {
-            completion(Result(DummyError.error))
+            completion(.failure(DummyError.error))
         }
     }
 
@@ -38,8 +38,8 @@ class AwaitTests: XCTestCase {
         do {
             let value = try await { throwingAsync("Hi", $0) }
             XCTFail("Unexpected success \(value)")
-        } catch let error as AnyError {
-            XCTAssertEqual(error.underlyingError as? DummyError, DummyError.error)
+        } catch {
+            XCTAssertEqual(error as? DummyError, DummyError.error)
         }
     }
 }

Tests/TSCBasicTests/ResultTests.swift

@@ -13,113 +13,55 @@ import XCTest
 import TSCBasic
 import TSCTestSupport
 
-private enum DummyError: Swift.Error {
+private enum DummyError: Error, Equatable {
     case somethingWentWrong
 }
 
-private enum OtherDummyError: Swift.Error {
+private enum OtherDummyError: Error, Equatable {
     case somethingElseWentWrong
     case andYetAnotherThingToGoWrong
 }
 
 class ResultTests: XCTestCase {
-
-    func testAnyError() {
-        func doSomething(right: Bool) -> Result<String, AnyError> {
-            if right {
-                return .success("All OK.")
-            }
-            return Result(DummyError.somethingWentWrong)
-        }
-
-        // Success.
-        switch doSomething(right: true) {
-        case .success(let string):
-            XCTAssertEqual(string, "All OK.")
-        case .failure(let error):
-            XCTFail("Unexpected failure: \(error)")
-        }
-
-        // Error.
-        switch doSomething(right: false) {
-        case .success(let string):
-            XCTFail("Unexpected success: \(string)")
-        case .failure(let error):
-            XCTAssertEqual(error.underlyingError as? DummyError, DummyError.somethingWentWrong)
-        }
-
-        do {
-            // Create an any error and check it doesn't nest.
-            let error = AnyError(DummyError.somethingWentWrong)
-            XCTAssertEqual(error.underlyingError as? DummyError, DummyError.somethingWentWrong)
-            let nested = AnyError(error)
-            XCTAssertEqual(nested.underlyingError as? DummyError, DummyError.somethingWentWrong)
-
-            // Check can create result directly from error.
-            let result: Result<String, AnyError> = Result(DummyError.somethingWentWrong)
-            if case let .failure(resultError) = result {
-                XCTAssertEqual(resultError.underlyingError as? DummyError, DummyError.somethingWentWrong)
-            } else {
-                XCTFail("Wrong result value \(result)")
-            }
-        }
-
-        do {
-            // Check any error closure initializer.
-            func throwing() throws -> String {
-                throw DummyError.somethingWentWrong
-            }
-            let result = Result(anyError: { try throwing() })
-            if case let .failure(resultError) = result {
-                XCTAssertEqual(resultError.underlyingError as? DummyError, DummyError.somethingWentWrong)
-            } else {
-                XCTFail("Wrong result value \(result)")
-            }
-        }
+    func testTryMap() {
+        let result1 = Result<Int, Error>.success(1).tryMap({ $0 + 1 })
+        XCTAssertEqual(result1.success, 2)
+
+        let result2 = Result<Int, Error>.failure(DummyError.somethingWentWrong).tryMap({ (value: Int) -> Int in
+            XCTFail("should not reach here")
+            return value
+        })
+        XCTAssertEqual(result2.failure as? DummyError, DummyError.somethingWentWrong)
+
+        let result3 = Result<Int, Error>.success(1).tryMap({ (value: Int) -> Int in
+            throw OtherDummyError.somethingElseWentWrong
+        })
+        XCTAssertEqual(result3.failure as? OtherDummyError, OtherDummyError.somethingElseWentWrong)
+
+        let result4 = Result<Int, Error>.failure(DummyError.somethingWentWrong).tryMap({ (value: Int) -> Int in
+            XCTFail("should not reach here")
+            throw OtherDummyError.somethingElseWentWrong
+        })
+        XCTAssertEqual(result4.failure as? DummyError, DummyError.somethingWentWrong)
     }
+}
 
-    func testMapAny() throws {
-        func throwing(_ shouldThrow: Bool) throws -> String {
-            if shouldThrow {
-                throw DummyError.somethingWentWrong
-            }
-            return " World"
-        }
-
-        // We should be able to map when we have value in result and our closure doesn't throw.
-        let success = Result<String, AnyError>.success("Hello").mapAny { value -> String in
-            let second = try throwing(false)
-            return value + second
-        }
-        XCTAssertEqual(try success.get(), "Hello World")
-
-        // We don't have a value, closure shouldn't matter.
-        let failure1 = Result<String, AnyError>(DummyError.somethingWentWrong).mapAny { value -> String in
-            let second = try throwing(false)
-            return value + second
-        }
-        XCTAssertThrowsAny(DummyError.somethingWentWrong) {
-            _ = try failure1.get()
-        }
-
-        // We have a value, but our closure throws.
-        let failure2 = Result<String, AnyError>.success("Hello").mapAny { value -> String in
-            let second = try throwing(true)
-            return value + second
-        }
-        XCTAssertThrowsAny(DummyError.somethingWentWrong) {
-            _ = try failure2.get()
+extension Result {
+    var success: Success? {
+        switch self {
+        case .success(let success):
+            return success
+        case .failure:
+            return nil
         }
     }
-}
 
-public func XCTAssertThrowsAny<T: Swift.Error>(_ expectedError: T, file: StaticString = #file, line: UInt = #line, _ body: () throws -> ()) where T: Equatable {
-    do {
-        try body()
-        XCTFail("body completed successfully", file: file, line: line)
-    } catch let error as AnyError {
-        XCTAssertEqual(error.underlyingError as? T, expectedError, file: file, line: line)
-    } catch {
-        XCTFail("unexpected error thrown", file: file, line: line)
+    var failure: Failure? {
+        switch self {
+        case .success:
+            return nil
+        case .failure(let error):
+            return error
+        }
     }
 }

Tests/TSCBasicTests/XCTestManifests.swift

@@ -343,8 +343,7 @@ extension ResultTests {
     //   `swift test --generate-linuxmain`
     // to regenerate.
     static let __allTests__ResultTests = [
-        ("testAnyError", testAnyError),
-        ("testMapAny", testMapAny),
+        ("testTryMap", testTryMap),
     ]
 }