Add additional value to suspensionOutcome enum and stop rethrowing

The new value indicates that the suspension failed because the executing thread already held a read lock to the suspension lock. This is an error state distinct from a failure due to an exception.

Author: MDoerner

Rubberduck.Parsing/VBA/IParseManager.cs

@@ -64,6 +64,10 @@ public enum SuspensionOutcome
         /// </summary>
         Canceled,
         /// <summary>
+        /// We already hold a read lock to the suspension lock; this indicates a bug in code.
+        /// </summary>
+        ReadLockAlreadyHeld,
+        /// <summary>
         /// An unexpected error; usually indicates a bug in code.
         /// </summary>
         UnexpectedError

Rubberduck.Parsing/VBA/ParseCoordinator.cs

@@ -116,7 +116,7 @@ public void SuspendRequested(object sender, RubberduckStatusSuspendParserEventAr
         {
             if (ParsingSuspendLock.IsReadLockHeld)
             {
-                e.Result = SuspensionOutcome.UnexpectedError;
+                e.Result = SuspensionOutcome.ReadLockAlreadyHeld;
                 const string errorMessage =
                     "A suspension action was attempted while a read lock was held. This indicates a bug in the code logic as suspension should not be requested from same thread that has a read lock.";
                 Logger.Error(errorMessage);
@@ -154,13 +154,11 @@ public void SuspendRequested(object sender, RubberduckStatusSuspendParserEventAr
             {
                 e.Result = SuspensionOutcome.Canceled;
                 e.EncounteredException = ex;
-                throw;
             }
             catch (Exception ex)
             {
                 e.Result = SuspensionOutcome.UnexpectedError;
                 e.EncounteredException = ex;
-                throw;
             }
             finally
             {

RubberduckTests/ParserState/ParserStateTests.cs

@@ -116,7 +116,58 @@ public void Test_RPS_SuspendParser_Exception_Suspending_Inside_Parse()
                 state.OnParseRequested(this);
             }
             Assert.IsFalse(wasSuspended);
-            Assert.AreEqual(SuspensionOutcome.UnexpectedError, result);
+            Assert.AreEqual(SuspensionOutcome.ReadLockAlreadyHeld, result);
+        }
+
+        [Test]
+        [Category("ParserState")]
+        public void Test_RPS_SuspendParser_Exception()
+        {
+            SuspensionResult result;
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                result = state.OnSuspendParser(this, AllowedRunStates, () => throw new NullReferenceException());
+            }
+
+            Assert.IsNotNull(result.EncounteredException);
+            Assert.AreEqual(typeof(NullReferenceException), result.EncounteredException.GetType());
+            Assert.AreEqual(SuspensionOutcome.UnexpectedError, result.Outcome);
+        }
+
+        [Test]
+        [Category("ParserState")]
+        public void Test_RPS_SuspendParser_Canceled()
+        {
+            SuspensionResult result;
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                result = state.OnSuspendParser(this, AllowedRunStates, () => throw new OperationCanceledException());
+            }
+
+            Assert.IsNotNull(result.EncounteredException);
+            Assert.AreEqual(typeof(OperationCanceledException), result.EncounteredException.GetType());
+            Assert.AreEqual(SuspensionOutcome.Canceled, result.Outcome);
+        }
+
+        [Test]
+        [Category("ParserState")]
+        public void Test_RPS_SuspendParser_IncompatibleState()
+        {
+            var result = SuspensionOutcome.Pending;
+            var wasRun = false;
+            var wasSuspended = false;
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                result = state.OnSuspendParser(this, new []{ParserState.Pending}, () => throw new OperationCanceledException()).Outcome;
+            }
+            Assert.IsFalse(wasSuspended);
+            Assert.AreEqual(SuspensionOutcome.IncompatibleState, result);
         }
 
         [Test]