Invocations refactoring

Mono.Debugging.Soft/SoftDebuggerAdaptor.cs

@@ -32,8 +32,7 @@
 using System.Reflection.Emit;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using System.Threading;
-
+using System.Threading.Tasks;
 using Mono.Debugger.Soft;
 using Mono.Debugging.Backend;
 using Mono.Debugging.Evaluation;
@@ -2145,100 +2144,112 @@ static string MirrorStringToString (EvaluationContext ctx, StringMirror mirror)
 		}
 	}
 
-	class MethodCall: AsyncOperation
+	internal class SoftOperationResult : OperationResult<Value>
 	{
-		readonly InvokeOptions options = InvokeOptions.DisableBreakpoints | InvokeOptions.SingleThreaded;
+		public SoftOperationResult (Value result, bool resultIsException, Value[] outArgs) : base (result, resultIsException)
+		{
+			OutArgs = outArgs;
+		}
 
-		readonly ManualResetEvent shutdownEvent = new ManualResetEvent (false);
+		public Value[] OutArgs { get; private set; }
+	}
+
+	internal class SoftMethodCall: AsyncOperationBase<Value>
+	{
+		readonly InvokeOptions options = InvokeOptions.DisableBreakpoints | InvokeOptions.SingleThreaded;
 		readonly SoftEvaluationContext ctx;
 		readonly MethodMirror function;
 		readonly Value[] args;
-		readonly object obj;
-		IAsyncResult handle;
-		Exception exception;
-		IInvokeResult result;
-
-		public MethodCall (SoftEvaluationContext ctx, MethodMirror function, object obj, Value[] args, bool enableOutArgs)
+		readonly IInvocableMethodOwnerMirror obj;
+		IInvokeAsyncResult invokeAsyncResult;
+
+		public SoftMethodCall (SoftEvaluationContext ctx, MethodMirror function, IInvocableMethodOwnerMirror obj, Value[] args, bool enableOutArgs)
 		{
 			this.ctx = ctx;
 			this.function = function;
 			this.obj = obj;
 			this.args = args;
 			if (enableOutArgs) {
-				this.options |= InvokeOptions.ReturnOutArgs;
+				options |= InvokeOptions.ReturnOutArgs;
 			}
 			if (function.VirtualMachine.Version.AtLeast (2, 40)) {
-				this.options |= InvokeOptions.Virtual;
+				options |= InvokeOptions.Virtual;
 			}
 		}
 
 		public override string Description {
-			get {
-				return function.DeclaringType.FullName + "." + function.Name;
-			}
-		}
-
-		public override void Invoke ()
-		{
-			try {
-				var invocableMirror = obj as IInvocableMethodOwnerMirror;
-				if (invocableMirror != null) {
-					var optionsToInvoke = options;
-					if (obj is StructMirror) {
-						optionsToInvoke |= InvokeOptions.ReturnOutThis;
-					}
-					handle = invocableMirror.BeginInvokeMethod (ctx.Thread, function, args, optionsToInvoke, null, null);
+			get
+			{
+				try {
+					return function.DeclaringType.FullName + "." + function.Name;
+				}
+				catch (Exception e) {
+					DebuggerLoggingService.LogError ("Exception during getting description of method", e);
+					return "[Unknown method]";
 				}
-				else
-					throw new ArgumentException ("Soft debugger method calls cannot be invoked on objects of type " + obj.GetType ().Name);
-			} catch (InvocationException ex) {
-				ctx.Session.StackVersion++;
-				exception = ex;
-			} catch (Exception ex) {
-				ctx.Session.StackVersion++;
-				DebuggerLoggingService.LogError ("Error in soft debugger method call thread on " + GetInfo (), ex);
-				exception = ex;
 			}
 		}
 
-		public override void Abort ()
-		{
-			if (handle is IInvokeAsyncResult) {
-				var info = GetInfo ();
-				DebuggerLoggingService.LogMessage ("Aborting invocation of " + info);
-				((IInvokeAsyncResult) handle).Abort ();
-				// Don't wait for the abort to finish. The engine will do it.
-			} else {
-				throw new NotSupportedException ();
-			}
-		}
-
-		public override void Shutdown ()
-		{
-			shutdownEvent.Set ();
-		}
-
-		void EndInvoke ()
+		protected override Task<OperationResult<Value>> InvokeAsyncImpl ()
 		{
 			try {
-				result = ((IInvocableMethodOwnerMirror) obj).EndInvokeMethodWithResult (handle);
-			} catch (InvocationException ex) {
-				if (!Aborting && ex.Exception != null) {
-					string ename = ctx.Adapter.GetValueTypeName (ctx, ex.Exception);
-					var vref = ctx.Adapter.GetMember (ctx, null, ex.Exception, "Message");
-
-					exception = vref != null ? new Exception (ename + ": " + (string) vref.ObjectValue) : new Exception (ename);
-					return;
+				var optionsToInvoke = options;
+				if (obj is StructMirror) {
+					optionsToInvoke |= InvokeOptions.ReturnOutThis;
 				}
-				exception = ex;
-			} catch (Exception ex) {
-				DebuggerLoggingService.LogError ("Error in soft debugger method call thread on " + GetInfo (), ex);
-				exception = ex;
-			} finally {
-				ctx.Session.StackVersion++;
+				var tcs = new TaskCompletionSource<OperationResult<Value>> ();
+				invokeAsyncResult = (IInvokeAsyncResult)obj.BeginInvokeMethod (ctx.Thread, function, args, optionsToInvoke, ar => {
+					try {
+						if (Token.IsCancellationRequested) {
+							tcs.SetCanceled ();
+							return;
+						}
+						var endInvokeResult = obj.EndInvokeMethodWithResult (ar);
+						tcs.SetResult (new SoftOperationResult (endInvokeResult.Result, false, endInvokeResult.OutArgs));
+					}
+					catch (InvocationException ex) {
+						if (ex.Exception != null) {
+							tcs.SetResult (new SoftOperationResult (ex.Exception, true, null));
+						}
+						else {
+							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 ();
+						}
+						else {
+							tcs.SetException (new EvaluatorException (e.Message));
+						}
+					}
+					catch (Exception 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 (string.Format ("Unexpected exception has thrown when ending invocation of {0}", GetInfo ()), e);
+							tcs.SetException (e);
+						}
+					}
+					finally {
+						UpdateSessionState ();
+					}
+				}, null);
+				return tcs.Task;
+			} catch (Exception e) {
+				UpdateSessionState ();
+				DebuggerLoggingService.LogError (string.Format ("Unexpected exception has thrown when invoking {0}", GetInfo ()), e);
+				throw;
 			}
 		}
-		
+
 		string GetInfo ()
 		{
 			try {
@@ -2250,41 +2261,26 @@ string GetInfo ()
 				else if (obj is StructMirror)
 					type = ((StructMirror)obj).Type;
 				return string.Format ("method {0} on object {1}",
-				                      function == null? "[null]" : function.FullName,
-				                      type == null? "[null]" : type.FullName);
+					function.FullName,
+					type == null? "[null]" : type.FullName);
 			} catch (Exception ex) {
 				DebuggerLoggingService.LogError ("Error getting info for SDB MethodCall", ex);
-				return "";
+				return "[Unknown method]";
 			}
 		}
 
-		public override bool WaitForCompleted (int timeout)
+		void UpdateSessionState ()
 		{
-			if (handle == null)
-				return true;
-			int res = WaitHandle.WaitAny (new WaitHandle[] { handle.AsyncWaitHandle, shutdownEvent }, timeout); 
-			if (res == 0) {
-				EndInvoke ();
-				return true;
-			}
-			// Return true if shut down.
-			return res == 1;
-		}
-
-		public Value ReturnValue {
-			get {
-				if (exception != null)
-					throw new EvaluatorException (exception.Message);
-				return result.Result;
-			}
+			ctx.Session.StackVersion++;
 		}
 
-		public Value[] OutArgs {
-			get {
-				if (exception != null)
-					throw new EvaluatorException (exception.Message);
-				return result.OutArgs;
+		protected override void AbortImpl (int abortCallTimes)
+		{
+			if (invokeAsyncResult == null) {
+				DebuggerLoggingService.LogError ("invokeAsyncResult is null", new ArgumentNullException ("invokeAsyncResult"));
+				return;
 			}
+			invokeAsyncResult.Abort ();
 		}
 	}
 }

Mono.Debugging.Soft/SoftEvaluationContext.cs

@@ -190,16 +190,19 @@ Value RuntimeInvoke (MethodMirror method, object target, Value[] values, bool en
 					DC.DebuggerLoggingService.LogMessage ("Thread state before evaluation is {0}", threadState);
 					throw new EvaluatorException ("Evaluation is not allowed when the thread is in 'Wait' state");
 				}
-				var mc = new MethodCall (this, method, target, values, enableOutArgs);
+				var invocableMirror = target as IInvocableMethodOwnerMirror;
+				if (invocableMirror == null)
+					throw new ArgumentException ("Soft debugger method calls cannot be invoked on objects of type " + target.GetType ().Name);
+				var mc = new SoftMethodCall (this, method, invocableMirror, values, enableOutArgs);
 				//Since runtime is returning NOT_SUSPENDED error if two methods invokes are executed
 				//at same time we have to lock invoking to prevent this...
 				lock (method.VirtualMachine) {
-					Adapter.AsyncExecute (mc, Options.EvaluationTimeout);
-				}
-				if (enableOutArgs) {
-					outArgs = mc.OutArgs;
+					var result = (SoftOperationResult)Adapter.InvokeSync (mc, Options.EvaluationTimeout).ThrowIfException (this);
+					if (enableOutArgs) {
+						outArgs = result.OutArgs;
+					}
+					return result.Result;
 				}
-				return mc.ReturnValue;
 			}
 		}
 

Mono.Debugging.Win32/CorDebuggerSession.cs

@@ -111,6 +111,13 @@ public static int EvaluationTimestamp {
 			get { return evaluationTimestamp; }
 		}
 
+		internal CorProcess Process
+		{
+			get
+			{
+				return process;
+			}
+		}
 
 		public override void Dispose ( )
 		{
@@ -1417,49 +1424,16 @@ public CorValue RuntimeInvoke (CorEvaluationContext ctx, CorFunction function, C
 				arguments.CopyTo (args, 1);
 			}
 
-			CorMethodCall mc = new CorMethodCall ();
-			CorValue exception = null;
-			CorEval eval = ctx.Eval;
-
-			DebugEventHandler<CorEvalEventArgs> completeHandler = delegate (object o, CorEvalEventArgs eargs) {
-				OnEndEvaluating ();
-				mc.DoneEvent.Set ();
-				eargs.Continue = false;
-			};
-
-			DebugEventHandler<CorEvalEventArgs> exceptionHandler = delegate(object o, CorEvalEventArgs eargs) {
-				OnEndEvaluating ();
-				exception = eargs.Eval.Result;
-				mc.DoneEvent.Set ();
-				eargs.Continue = false;
-			};
-
-			process.OnEvalComplete += completeHandler;
-			process.OnEvalException += exceptionHandler;
-
-			mc.OnInvoke = delegate {
-				if (function.GetMethodInfo (this).Name == ".ctor")
-					eval.NewParameterizedObject (function, typeArgs, args);
-				else
-					eval.CallParameterizedFunction (function, typeArgs, args);
-				process.SetAllThreadsDebugState (CorDebugThreadState.THREAD_SUSPEND, ctx.Thread);
-				ClearEvalStatus ();
-				OnStartEvaluating ();
-				process.Continue (false);
-			};
-			mc.OnAbort = delegate {
-				eval.Abort ();
-			};
-			mc.OnGetDescription = delegate {
-				MethodInfo met = function.GetMethodInfo (ctx.Session);
-				if (met != null)
-					return met.DeclaringType.FullName + "." + met.Name;
-				else
-					return "<Unknown>";
-			};
-
+			var methodCall = new CorMethodCall (ctx, function, typeArgs, args);
 			try {
-				ObjectAdapter.AsyncExecute (mc, ctx.Options.EvaluationTimeout);
+				var result = ObjectAdapter.InvokeSync (methodCall, ctx.Options.EvaluationTimeout);
+				if (result.ResultIsException) {
+					var vref = new CorValRef (result.Result);
+					throw new EvaluatorExceptionThrownException (vref, ObjectAdapter.GetValueTypeName (ctx, vref));
+				}
+
+				WaitUntilStopped ();
+				return result.Result;
 			}
 			catch (COMException ex) {
 				// eval exception is a 'good' exception that should be shown in value box
@@ -1469,35 +1443,16 @@ public CorValue RuntimeInvoke (CorEvaluationContext ctx, CorFunction function, C
 					throw evalException;
 				throw;
 			}
-			finally {
-				process.OnEvalComplete -= completeHandler;
-				process.OnEvalException -= exceptionHandler;
-			}
-
-			WaitUntilStopped ();
-			if (exception != null) {
-/*				ValueReference<CorValue, CorType> msg = ctx.Adapter.GetMember (ctx, val, "Message");
-				if (msg != null) {
-					string s = msg.ObjectValue as string;
-					mc.ExceptionMessage = s;
-				}
-				else
-					mc.ExceptionMessage = "Evaluation failed.";*/
-				CorValRef vref = new CorValRef (exception);
-				throw new EvaluatorException ("Evaluation failed: " + ObjectAdapter.GetValueTypeName (ctx, vref));
-			}
-
-			return eval.Result;
 		}
 
-		void OnStartEvaluating ( )
+		internal void OnStartEvaluating ( )
 		{
 			lock (debugLock) {
 				evaluating = true;
 			}
 		}
 
-		void OnEndEvaluating ( )
+		internal void OnEndEvaluating ( )
 		{
 			lock (debugLock) {
 				evaluating = false;
@@ -1603,7 +1558,7 @@ public void WaitUntilStopped ()
 			}
 		}
 
-		void ClearEvalStatus ( )
+		internal void ClearEvalStatus ( )
 		{
 			foreach (CorProcess p in dbg.Processes) {
 				if (p.Id == processId) {