From f68e545cd731c757df6a043a18b324bb9199b337 Mon Sep 17 00:00:00 2001
From: Sho Ikeda <suicaicoca@gmail.com>
Date: Fri, 25 Feb 2022 19:06:17 +0900
Subject: [PATCH] Fix `succeed` matcher type inference issue

---
 Sources/Nimble/Matchers/ToSucceed.swift       |  8 +++---
 .../NimbleTests/Matchers/ToSucceedTest.swift  | 25 +++++++++++--------
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/Sources/Nimble/Matchers/ToSucceed.swift b/Sources/Nimble/Matchers/ToSucceed.swift
index 0b52ee9a1..d9c616a68 100644
--- a/Sources/Nimble/Matchers/ToSucceed.swift
+++ b/Sources/Nimble/Matchers/ToSucceed.swift
@@ -1,5 +1,5 @@
 /**
- Used by the `toSucceed` matcher.
+ Used by the `succeed` matcher.
 
  This is the return type for the closure.
  */
@@ -14,14 +14,14 @@ public enum ToSucceedResult {
  Return `.succeeded` when the validation succeeds.
  Return `.failed` with a failure reason when the validation fails.
  */
-public func succeed() -> Predicate<() -> ToSucceedResult> {
+public func succeed() -> Predicate<ToSucceedResult> {
     return Predicate.define { actualExpression in
         let optActual = try actualExpression.evaluate()
         guard let actual = optActual else {
-            return PredicateResult(status: .fail, message: .fail("expected a closure, got <nil>"))
+            return PredicateResult(status: .fail, message: .fail("expected a ToSucceedResult, got <nil>"))
         }
 
-        switch actual() {
+        switch actual {
         case .succeeded:
             return PredicateResult(
                 bool: true,
diff --git a/Tests/NimbleTests/Matchers/ToSucceedTest.swift b/Tests/NimbleTests/Matchers/ToSucceedTest.swift
index df6b0aa40..e19dd3876 100644
--- a/Tests/NimbleTests/Matchers/ToSucceedTest.swift
+++ b/Tests/NimbleTests/Matchers/ToSucceedTest.swift
@@ -3,28 +3,33 @@ import Nimble
 
 final class ToSucceedTest: XCTestCase {
     func testToSucceed() {
-        expect({
+        expect {
             return .succeeded
-        }).to(succeed())
+        }.to(succeed())
 
-        expect({
+        expect {
             return .failed(reason: "")
-        }).toNot(succeed())
+        }.toNot(succeed())
 
-        failsWithErrorMessageForNil("expected a closure, got <nil>") {
-            expect(nil as (() -> ToSucceedResult)?).to(succeed())
+        expect {
+            let result = ToSucceedResult.succeeded
+            return result
+        }.to(succeed())
+
+        failsWithErrorMessageForNil("expected a ToSucceedResult, got <nil>") {
+            expect(nil).to(succeed())
         }
 
         failsWithErrorMessage("expected to succeed, got <failed> because <something went wrong>") {
-            expect({
+            expect {
                 .failed(reason: "something went wrong")
-            }).to(succeed())
+            }.to(succeed())
         }
 
         failsWithErrorMessage("expected to not succeed, got <succeeded>") {
-            expect({
+            expect {
                 return .succeeded
-            }).toNot(succeed())
+            }.toNot(succeed())
         }
     }
 }