From 44233223ebdf328cb7264738c6ac8b1ee1af5a4b Mon Sep 17 00:00:00 2001
From: Lukas Gasselsberger <it@voecklabrucker-freikirche.at>
Date: Mon, 31 Jul 2023 17:28:15 +0200
Subject: [PATCH] Revert changes in `ContinuedAssertionScope.cs`

---
 .../Execution/ContinuedAssertionScope.cs      | 99 +++++++++++++++----
 1 file changed, 81 insertions(+), 18 deletions(-)

diff --git a/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs b/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs
index 561ea0d78a..52cddb56f5 100644
--- a/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs
+++ b/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs
@@ -21,32 +21,81 @@ internal ContinuedAssertionScope(AssertionScope predecessor, bool continueAssert
     }
 
     /// <inheritdoc/>
-    public GivenSelector<T> Given<T>(Func<T> selector) =>
-        continueAsserting ? predecessor.Given(selector) : new GivenSelector<T>(() => default, predecessor, continueAsserting: false);
+    public GivenSelector<T> Given<T>(Func<T> selector)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.Given(selector);
+        }
+
+        return new GivenSelector<T>(() => default, predecessor, continueAsserting: false);
+    }
 
     /// <inheritdoc/>
-    public IAssertionScope ForCondition(bool condition) =>
-        continueAsserting ? predecessor.ForCondition(condition) : this;
+    public IAssertionScope ForCondition(bool condition)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.ForCondition(condition);
+        }
+
+        return this;
+    }
 
     /// <inheritdoc/>
-    public Continuation FailWith(string message) =>
-        continueAsserting ? predecessor.FailWith(message) : new Continuation(predecessor, continueAsserting: false);
+    public Continuation FailWith(string message)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.FailWith(message);
+        }
+
+        return new Continuation(predecessor, continueAsserting: false);
+    }
 
     /// <inheritdoc/>
-    public Continuation FailWith(string message, params Func<object>[] argProviders) =>
-        continueAsserting ? predecessor.FailWith(message, argProviders) : new Continuation(predecessor, continueAsserting: false);
+    public Continuation FailWith(string message, params Func<object>[] argProviders)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.FailWith(message, argProviders);
+        }
+
+        return new Continuation(predecessor, continueAsserting: false);
+    }
 
     /// <inheritdoc/>
-    public Continuation FailWith(Func<FailReason> failReasonFunc) =>
-        continueAsserting ? predecessor.FailWith(failReasonFunc) : new Continuation(predecessor, continueAsserting: false);
+    public Continuation FailWith(Func<FailReason> failReasonFunc)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.FailWith(failReasonFunc);
+        }
+
+        return new Continuation(predecessor, continueAsserting: false);
+    }
 
     /// <inheritdoc/>
-    public Continuation FailWith(string message, params object[] args) =>
-        continueAsserting ? predecessor.FailWith(message, args) : new Continuation(predecessor, continueAsserting: false);
+    public Continuation FailWith(string message, params object[] args)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.FailWith(message, args);
+        }
+
+        return new Continuation(predecessor, continueAsserting: false);
+    }
 
     /// <inheritdoc/>
-    public IAssertionScope BecauseOf(string because, params object[] becauseArgs) =>
-        continueAsserting ? predecessor.BecauseOf(because, becauseArgs) : this;
+    public IAssertionScope BecauseOf(string because, params object[] becauseArgs)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.BecauseOf(because, becauseArgs);
+        }
+
+        return this;
+    }
 
     /// <inheritdoc/>
     public Continuation ClearExpectation()
@@ -57,12 +106,26 @@ public Continuation ClearExpectation()
     }
 
     /// <inheritdoc/>
-    public IAssertionScope WithExpectation(string message, params object[] args) =>
-        continueAsserting ? predecessor.WithExpectation(message, args) : this;
+    public IAssertionScope WithExpectation(string message, params object[] args)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.WithExpectation(message, args);
+        }
+
+        return this;
+    }
 
     /// <inheritdoc/>
-    public IAssertionScope WithDefaultIdentifier(string identifier) =>
-        continueAsserting ? predecessor.WithDefaultIdentifier(identifier) : this;
+    public IAssertionScope WithDefaultIdentifier(string identifier)
+    {
+        if (continueAsserting)
+        {
+            return predecessor.WithDefaultIdentifier(identifier);
+        }
+
+        return this;
+    }
 
     /// <inheritdoc/>
     public IAssertionScope UsingLineBreaks => predecessor.UsingLineBreaks;