Invocation is awaited infinitely as it was before.

Better handling of exeptions in Soft invocations

Author: nerzhulart

Mono.Debugging.Soft/SoftDebuggerAdaptor.cs

@@ -2212,8 +2212,29 @@ protected override Task<OperationResult<Value>> InvokeAsyncImpl (CancellationTok
 							tcs.SetException (new EvaluatorException ("Target method has thrown an exception but the exception object is inaccessible"));
 						}
 					}
+					catch (CommandException e) {
+						if (e.ErrorCode == ErrorCode.INVOKE_ABORTED) {
+							tcs.TrySetCanceled ();
+							token.ThrowIfCancellationRequested ();
+						}
+						else {
+							tcs.SetException (new EvaluatorException (e.Message));
+						}
+					}
 					catch (Exception e) {
-						tcs.SetException (e);
+						if (e is ObjectCollectedException ||
+							e is InvalidStackFrameException ||
+							e is VMNotSuspendedException ||
+							e is NotSupportedException ||
+							e is AbsentInformationException ||
+							e is ArgumentException) {
+							// user meaningfull evaluation exception -> wrap with EvaluatorException that will be properly shown in value viewer
+							tcs.SetException (new EvaluatorException (e.Message));
+						}
+						else {
+							DebuggerLoggingService.LogError ("Unexpected exception has thrown in Invocation", e);
+							tcs.SetException (e);
+						}
 					}
 					finally {
 						UpdateSessionState ();

Mono.Debugging/Mono.Debugging.Evaluation/AsyncOperationManager.cs

@@ -51,7 +51,6 @@ public OperationData (IAsyncOperationBase operation, CancellationTokenSource tok
 		readonly HashSet<OperationData> currentOperations = new HashSet<OperationData> ();
 		bool disposed = false;
 		const int ShortCancelTimeout = 100;
-		const int LongCancelTimeout = 1000;
 
 		static bool IsOperationCancelledException (Exception e, int depth = 4)
 		{
@@ -125,24 +124,34 @@ public OperationResult<TValue> Invoke<TValue> (AsyncOperationBase<TValue> mc, in
 
 		public event EventHandler<BusyStateEventArgs> BusyStateChanged = delegate {  };
 
+		void ChangeBusyState (bool busy, string description)
+		{
+			try {
+				BusyStateChanged (this, new BusyStateEventArgs {IsBusy = true, Description = description});
+			}
+			catch (Exception e) {
+				DebuggerLoggingService.LogError ("Exception during ChangeBusyState", e);
+			}
+		}
+
 		void WaitAfterCancel (IAsyncOperationBase op)
 		{
 			var desc = op.Description;
 			DebuggerLoggingService.LogMessage (string.Format ("Waiting for cancel of invoke {0}", desc));
 			try {
 				if (!op.RawTask.Wait (ShortCancelTimeout)) {
 					try {
-						BusyStateChanged (this, new BusyStateEventArgs {IsBusy = true, Description = desc});
-						op.RawTask.Wait (LongCancelTimeout);
+						ChangeBusyState (true, desc);
+						op.RawTask.Wait (Timeout.Infinite);
 					}
 					finally {
-						BusyStateChanged (this, new BusyStateEventArgs {IsBusy = false, Description = desc});
+						ChangeBusyState (false, desc);
 					}
 				}
 			}
 			finally {
 				DebuggerLoggingService.LogMessage (string.Format ("Calling AfterCancelled() for {0}", desc));
-				op.AfterCancelled (ShortCancelTimeout + LongCancelTimeout);
+				op.AfterCancelled (ShortCancelTimeout);
 			}
 		}