Merge branch 'vscode-debugger' into develop

Author: zone117x

Meadow.CoverageReport/Debugging/ExecutionTraceAnalysis.cs

@@ -128,7 +128,8 @@ public ExecutionTraceAnalysis(ExecutionTrace executionTrace)
             ParseStateVariableDeclarations();
 
             // Parse our entire execution trace.
-            ParseScopes(0, 0, 0, null);
+            SourceMapEntry? lastEntry = null;
+            ParseScopes(0, 0, 0, null, ref lastEntry);
         }
         #endregion
 
@@ -776,15 +777,12 @@ private void ParseScopeTracepoint(int traceIndex, SourceMapEntry currentEntry, E
         /// <param name="callDepth">The depth of calls at this point in the scan. This refers to the EVM message depth at this point in execution.</param>
         /// <param name="parentScope">References the immediate parent scope which contains this scope. Can be null (for root).</param>
         /// <returns>Returns the next trace index to continue from for the calling scope.</returns>
-        private int ParseScopes(int traceIndex, int scopeDepth, int callDepth, ExecutionTraceScope parentScope)
+        private int ParseScopes(int traceIndex, int scopeDepth, int callDepth, ExecutionTraceScope parentScope, ref SourceMapEntry? lastEntry)
         {
             // Backup our scope start and create an entry in our dictionary (some properties of which we'll populate later)
             int scopeStartIndex = traceIndex;
             ExecutionTraceScope currentScope = new ExecutionTraceScope(scopeStartIndex, scopeDepth, callDepth, parentScope);
 
-            // The last map entry obtained in the loop. 
-            SourceMapEntry? lastEntry = null;
-
             // Loop until the end of the trace
             while (traceIndex < ExecutionTrace.Tracepoints.Length)
             {
@@ -831,16 +829,23 @@ private int ParseScopes(int traceIndex, int scopeDepth, int callDepth, Execution
                     significantStep = true;
                 }
 
-                // If an exception occurred at this step, it's a significant step
-                if (_exceptionLookup.ContainsKey(traceIndex))
+                // If an exception occurred at this step, it's a significant step. If we 
+                // didn't already mark this as a significant step, it means this line is 
+                // represented in our last trace index. We remove the last trace index,
+                // and mark this step as significant so it is added instead.
+                if (!significantStep && _exceptionLookup.ContainsKey(traceIndex))
                 {
+                    // Remove the last step from our significant step index, and set this
+                    // one as significant so it is used instead.
+                    SignificantStepIndices.RemoveAt(SignificantStepIndices.Count - 1);
                     significantStep = true;
                 }
 
-                // If this is a significant step, add it to our list
+                // If this is a significant step, add it to our list, and set the last entry.
                 if (significantStep)
                 {
                     SignificantStepIndices.Add(traceIndex);
+                    lastEntry = currentEntry;
                 }
 
                 // Determine if we're in an external call
@@ -869,7 +874,7 @@ private int ParseScopes(int traceIndex, int scopeDepth, int callDepth, Execution
                     int childScopeDepth = scopeDepth + 1;
 
                     // Parse our child scope and set our (potentially) advanced trace index
-                    traceIndex = ParseScopes(childStartIndex, childScopeDepth, childCallDepth, currentScope);
+                    traceIndex = ParseScopes(childStartIndex, childScopeDepth, childCallDepth, currentScope, ref lastEntry);
                 }
                 else if (exitingScope)
                 {
@@ -884,9 +889,6 @@ private int ParseScopes(int traceIndex, int scopeDepth, int callDepth, Execution
                     ParseScopeTracepoint(traceIndex, currentEntry, currentScope);
                 }
 
-                // Set our last entry
-                lastEntry = currentEntry;
-
                 // Increment our trace index
                 traceIndex++;
             }

Meadow.DebugAdapterServer/MeadowDebugAdapterState.cs

@@ -12,7 +12,6 @@ public class MeadowDebugAdapterThreadState
     {
         #region Fields
         private int _significantStepIndexIndex;
-        public int? LastExceptionTraceIndex;
         #endregion
 
         #region Properties

Meadow.DebugAdapterServer/MeadowSolidityDebugAdapter.cs

@@ -128,79 +128,109 @@ public async Task ProcessExecutionTraceAnalysis(ExecutionTraceAnalysis traceAnal
             _processTraceSemaphore.Release();
         }
 
-        private void ContinueExecution(MeadowDebugAdapterThreadState threadState, DesiredControlFlow controlFlow = DesiredControlFlow.Continue)
+        private void ContinueExecution(MeadowDebugAdapterThreadState threadState, DesiredControlFlow controlFlowAction = DesiredControlFlow.Continue, int stepsPriorToAction = 0)
         {
             // Unlink our data for our thread id.
             ReferenceContainer.UnlinkThreadId(threadState.ThreadId);
 
-            // Verify we don't have an exception at this point that we haven't already handled, if we do, break out.
-            if (threadState.LastExceptionTraceIndex != threadState.CurrentStepIndex && HandleExceptions(threadState))
+            // Create a variable to track if we have finished stepping through the execution.
+            bool finishedExecution = false;
+
+            // Determine the direction to take steps prior to any evaluation.
+            if (stepsPriorToAction >= 0)
             {
-                return;
+                // Loop for each step to take forward.
+                for (int i = 0; i < stepsPriorToAction; i++)
+                {
+                    // Take a step forward, if we could not, we finished execution, so we can stop looping.
+                    if (!threadState.IncrementStep())
+                    {
+                        finishedExecution = true;
+                        break;
+                    }
+                }
             }
-
-            // Determine how to continue execution.
-            bool finishedExecution = false;
-            switch (controlFlow)
+            else
             {
-                case DesiredControlFlow.StepOver:
-                // TODO: Implement
-
-                case DesiredControlFlow.StepInto:
+                // Loop for each step to take backward
+                for (int i = 0; i > stepsPriorToAction; i--)
+                {
+                    // Take a step backward, if we could not, we can stop early as we won't be able to step backwards anymore.
+                    if (!threadState.DecrementStep())
                     {
-                        // Increment our step
-                        finishedExecution = !threadState.IncrementStep();
-
-                        // Signal our breakpoint event has occurred for this thread.
-                        Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Step) { ThreadId = threadState.ThreadId });
                         break;
                     }
+                }
+            }
 
-                case DesiredControlFlow.StepOut:
-                // TODO: Implement
+            // If we haven't finished execution, 
+            if (!finishedExecution)
+            {
+                switch (controlFlowAction)
+                {
+                    case DesiredControlFlow.StepOver:
+                    // TODO: Implement
 
-                case DesiredControlFlow.StepBackwards:
-                    {
-                        // Decrement our step
-                        threadState.DecrementStep();
+                    case DesiredControlFlow.StepInto:
+                        {
+                            // Increment our step
+                            finishedExecution = !threadState.IncrementStep();
 
-                        // Signal our breakpoint event has occurred for this thread.
-                        Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Step) { ThreadId = threadState.ThreadId });
+                            // If we stepped successfully, we evaluate, and if an event is encountered, we stop.
+                            if (!finishedExecution && EvaluateCurrentStep(threadState))
+                            {
+                                return;
+                            }
 
-                        // TODO: Check if we couldn't decrement step. Disable step backward if we can.
-                        break;
-                    }
+                            // Signal our breakpoint event has occurred for this thread.
+                            Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Step) { ThreadId = threadState.ThreadId });
+                            break;
+                        }
 
-                case DesiredControlFlow.Continue:
-                    {
-                        // Process the execution trace analysis
-                        while (threadState.CurrentStepIndex.HasValue && !Exiting)
+                    case DesiredControlFlow.StepOut:
+                    // TODO: Implement
+
+                    case DesiredControlFlow.StepBackwards:
                         {
-                            // Obtain our breakpoints.
-                            bool hitBreakpoint = CheckBreakpointExists(threadState);
+                            // Decrement our step
+                            bool decrementedStep = threadState.DecrementStep();
 
-                            // If we hit a breakpoint, we can signal our breakpoint and exit this execution method.
-                            if (hitBreakpoint)
+                            // If we stepped successfully, we evaluate, and if an event is encountered, we stop.
+                            if (decrementedStep && EvaluateCurrentStep(threadState))
                             {
-                                // Signal our breakpoint event has occurred for this thread.
-                                Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Breakpoint) { ThreadId = threadState.ThreadId });
                                 return;
                             }
 
-                            // Increment our position
-                            bool successfulStep = threadState.IncrementStep();
+                            // Signal our breakpoint event has occurred for this thread.
+                            Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Step) { ThreadId = threadState.ThreadId });
 
-                            // If we couldn't step, break out of our loop
-                            if (!successfulStep)
+                            // TODO: Check if we couldn't decrement step. Disable step backward if we can.
+                            break;
+                        }
+
+                    case DesiredControlFlow.Continue:
+                        {
+                            // Process the execution trace analysis
+                            while (threadState.CurrentStepIndex.HasValue && !Exiting)
                             {
-                                break;
+                                // If we encountered an event at this point, stop
+                                if (EvaluateCurrentStep(threadState))
+                                {
+                                    return;
+                                }
+
+                                // If we couldn't step forward, this trace has been fully processed.
+                                if (!threadState.IncrementStep())
+                                {
+                                    break;
+                                }
                             }
-                        }
 
-                        // If we exited this way, our execution has concluded because we could not step any further (or there were never any steps).
-                        finishedExecution = true;
-                        break;
-                    }
+                            // If we exited this way, our execution has concluded because we could not step any further (or there were never any steps).
+                            finishedExecution = true;
+                            break;
+                        }
+                }
             }
 
             // If we finished execution, signal our thread
@@ -210,6 +240,12 @@ private void ContinueExecution(MeadowDebugAdapterThreadState threadState, Desire
             }
         }
 
+        private bool EvaluateCurrentStep(MeadowDebugAdapterThreadState threadState, bool exceptions = true, bool breakpoints = true)
+        {
+            // Evaluate exceptions and breakpoints at this point in execution.
+            return (exceptions && HandleExceptions(threadState)) || (breakpoints && HandleBreakpoint(threadState));
+        }
+
         private bool HandleExceptions(MeadowDebugAdapterThreadState threadState)
         {
             // Try to obtain an exception at this point
@@ -221,9 +257,6 @@ private bool HandleExceptions(MeadowDebugAdapterThreadState threadState)
                 // If we have an exception, throw it and return the appropriate status.
                 if (traceException != null)
                 {
-                    // Set our last exception index.
-                    threadState.LastExceptionTraceIndex = threadState.CurrentStepIndex.Value;
-
                     // Send our exception event.
                     var stoppedEvent = new StoppedEvent(StoppedEvent.ReasonValue.Exception)
                     {
@@ -235,14 +268,11 @@ private bool HandleExceptions(MeadowDebugAdapterThreadState threadState)
                 }
             }
 
-            // If there was no exception, clear our last exception trace index
-            threadState.LastExceptionTraceIndex = null;
-
             // We did not find an exception here, return false
             return false;
         }
 
-        private bool CheckBreakpointExists(MeadowDebugAdapterThreadState threadState)
+        private bool HandleBreakpoint(MeadowDebugAdapterThreadState threadState)
         {
             // Verify we have a valid step at this point.
             if (!threadState.CurrentStepIndex.HasValue)
@@ -264,6 +294,8 @@ private bool CheckBreakpointExists(MeadowDebugAdapterThreadState threadState)
                 bool containsBreakpoint = success && breakpointLines.Any(x => x == sourceLine.LineNumber);
                 if (containsBreakpoint)
                 {
+                    // Signal our breakpoint event has occurred for this thread.
+                    Protocol.SendEvent(new StoppedEvent(StoppedEvent.ReasonValue.Breakpoint) { ThreadId = threadState.ThreadId });
                     return true;
                 }
             }
@@ -422,11 +454,11 @@ protected override void HandleContinueRequestAsync(IRequestResponder<ContinueArg
             bool success = ThreadStates.TryGetValue(responder.Arguments.ThreadId, out var threadState);
             if (success)
             {
-                // Advance our step from our current position
-                threadState.IncrementStep();
-
-                // Continue executing
-                ContinueExecution(threadState, DesiredControlFlow.Continue);
+                // Continue executing, taking one step before continuing, as evaluation occurs before steps occur, and we want
+                // to ensure we advanced position from our last and don't re-evaluate the same trace point. We only do this on
+                // startup since we want the initial trace point to be evaluated. After that, we want to force advancement by
+                // at least one step before continuation/re-evaluation.
+                ContinueExecution(threadState, DesiredControlFlow.Continue, 1);
             }
         }
 

Meadow.JsonRpc.Client/JsonRpcClient.cs

@@ -405,10 +405,8 @@ public async Task<Hash> SendTransaction(TransactionParams transactionParams)
 
             var (error, result) = await InvokeRpcMethod(request, throwOnError: false);
 
-            if (JsonRpcExecutionAnalysis != null)
-            {
-                await JsonRpcExecutionAnalysis(_thisInterface);
-            }
+            // Invoke our execution analysis hook.
+            await (JsonRpcExecutionAnalysis?.Invoke(_thisInterface) ?? Task.CompletedTask);
 
             if (error != null)
             {
@@ -441,10 +439,8 @@ public async Task<byte[]> Call(CallParams callParams, DefaultBlockParameter bloc
 
             var (error, result) = await InvokeRpcMethod(request, throwOnError: false);
 
-            if (JsonRpcExecutionAnalysis != null)
-            {
-                await JsonRpcExecutionAnalysis(_thisInterface);
-            }
+            // Invoke our execution analysis hook.
+            await (JsonRpcExecutionAnalysis?.Invoke(_thisInterface) ?? Task.CompletedTask);
 
             if (error != null)
             {