Support navigating to decompiled code from CallStackPad and RunningThreadsPad.

data/resources/StringResources.resx

@@ -5803,6 +5803,9 @@ Unable to find 'WelcomeDialogId' in Dialogs.wxs</comment>
   <data name="MainWindow.Windows.Debug.CallStack.CannotSwitchWithoutSymbols" xml:space="preserve">
     <value>You cannot switch to a function without symbols.</value>
   </data>
+  <data name="MainWindow.Windows.Debug.CallStack.CannotSwitchWithoutSymbolsOrDecompiledCodeOptions" xml:space="preserve">
+    <value>You cannot switch to a function without symbols without enabling decompiled code options.</value>
+  </data>
   <data name="MainWindow.Windows.Debug.CallStack.ExternalMethods" xml:space="preserve">
     <value>[External methods]</value>
     <comment>Show in the callstack instead of external methods (without symbols)</comment>
@@ -6117,6 +6120,12 @@ Shows the full callstack of the error.</comment>
   <data name="MainWindow.Windows.Debug.Threads.ThreadSwitch" xml:space="preserve">
     <value>Thread switch</value>
   </data>
+  <data name="MainWindow.Windows.Debug.Threads.CannotSwitchWithoutDecompiledCodeOptions" xml:space="preserve">
+    <value>You cannot switch to a thread in decompiled code without enabling decomplied code options.</value>
+  </data>
+  <data name="MainWindow.Windows.Debug.Threads.CannotSwitchOnNAFrame" xml:space="preserve">
+    <value>You cannot switch to a thread with no available frame.</value>
+  </data>
   <data name="MainWindow.Windows.Debug.ToggleMethodView" xml:space="preserve">
     <value>Toggle Method View</value>
   </data>

src/AddIns/Debugger/Debugger.AddIn/Pads/CallStackPad.xaml.cs

@@ -116,13 +116,16 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				if (item == null)
 					return;
 
-				if (item.Frame.HasSymbols) {
-					if (debuggedProcess.SelectedThread != null) {
-						debuggedProcess.SelectedThread.SelectedStackFrame = item.Frame;
-						debuggedProcess.OnPaused(); // Force refresh of pads
+				if (item.Frame != null && debuggedProcess.SelectedThread != null) {
+					// check for options - if these options are enabled, selecting the frame should not continue
+					if (!item.Frame.HasSymbols && (debuggedProcess.Options.EnableJustMyCode || debuggedProcess.Options.StepOverNoSymbols)) {
+						MessageService.ShowMessage("${res:MainWindow.Windows.Debug.CallStack.CannotSwitchWithoutSymbolsOrDecompiledCodeOptions}",
+						                           "${res:MainWindow.Windows.Debug.CallStack.FunctionSwitch}");
+						return;
 					}
-				} else {
-					MessageService.ShowMessage("${res:MainWindow.Windows.Debug.CallStack.CannotSwitchWithoutSymbols}", "${res:MainWindow.Windows.Debug.CallStack.FunctionSwitch}");
+					debuggedProcess.SelectedThread.SelectedStackFrame = item.Frame;
+					debuggedProcess.PauseSession.PausedReason = PausedReason.CurrentFunctionChanged;
+					debuggedProcess.OnPaused(); // Force refresh of pads - artificial pause
 				}
 			} else {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.CallStack.CannotSwitchWhileRunning}", "${res:MainWindow.Windows.Debug.CallStack.FunctionSwitch}");
@@ -145,12 +148,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			}
 			
 			List<CallStackItem> items = null;
-			StackFrame activeFrame = null;
 			using(new PrintTimes("Callstack refresh")) {
 				try {
 					Utils.DoEvents(debuggedProcess);
 					items = CreateItems().ToList();
-					activeFrame = debuggedProcess.SelectedThread.SelectedStackFrame;
 				} catch(AbortedBecauseDebuggeeResumedException) {
 				} catch(System.Exception) {
 					if (debuggedProcess == null || debuggedProcess.HasExited) {
@@ -161,7 +162,6 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				}
 			}
 			view.ItemsSource = items;
-			view.SelectedItem = items != null ? items.FirstOrDefault(item => object.Equals(activeFrame, item.Frame)) : null;
 		}
 		
 		IEnumerable<CallStackItem> CreateItems()
@@ -192,6 +192,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 						Name = GetFullName(frame), Language = "", Line = lineNumber, ModuleName = moduleName
 					};
 					lastItemIsExternalMethod = false;
+					item.Frame = frame;
 				} else {
 					// Show [External methods] in the list
 					if (lastItemIsExternalMethod) continue;
@@ -201,7 +202,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 					};
 					lastItemIsExternalMethod = true;
 				}
-				item.Frame = frame;
+				
 				yield return item;
 				
 				Utils.DoEvents(debuggedProcess);

src/AddIns/Debugger/Debugger.AddIn/Pads/ConsolePad.cs

@@ -52,12 +52,14 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				return "The process is running";
 			}
 			try {
-				var context = !process.IsInExternalCode ? process.SelectedStackFrame : process.SelectedThread.MostRecentStackFrame;
 				var debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
-				object data = debugger.debuggerDecompilerService.GetLocalVariableIndex(context.MethodInfo.DeclaringType.MetadataToken, 
-				                                                                       context.MethodInfo.MetadataToken, 
+				StackFrame frame = debugger.DebuggedProcess.GetCurrentExecutingFrame();
+				if (frame == null) return "No current execution frame";
+				
+				object data = debugger.debuggerDecompilerService.GetLocalVariableIndex(frame.MethodInfo.DeclaringType.MetadataToken,
+				                                                                       frame.MethodInfo.MetadataToken,
 				                                                                       code);
-				Value val = ExpressionEvaluator.Evaluate(code, SelectedLanguage, context, data);
+				Value val = ExpressionEvaluator.Evaluate(code, SelectedLanguage, frame, data);
 				return ExpressionEvaluator.FormatValue(val);
 			} catch (GetValueException e) {
 				return e.Message;
@@ -112,8 +114,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			if (this.process == null || this.process.IsRunning)
 				return;
 			
-			var context = !process.IsInExternalCode ? process.SelectedStackFrame : process.SelectedThread.MostRecentStackFrame;
-			if (context == null)
+			StackFrame frame = this.process.GetCurrentExecutingFrame();
+			if (frame == null)
 				return;
 			
 			foreach (char ch in e.Text) {
@@ -125,11 +127,13 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		
 		void ShowDotCompletion(string currentText)
 		{
-			var context = !process.IsInExternalCode ? process.SelectedStackFrame : process.SelectedThread.MostRecentStackFrame;
-			if (context == null)
+			StackFrame frame = this.process.GetCurrentExecutingFrame();
+			if (frame == null)
 				return;
 			
-			var seg = context.NextStatement;
+			var seg = frame.NextStatement;
+			if (seg == null)
+				return;
 			
 			var expressionFinder = ParserService.GetExpressionFinder(seg.Filename);
 			var info = ParserService.GetParseInformation(seg.Filename);

src/AddIns/Debugger/Debugger.AddIn/Pads/LocalVarPad.cs

@@ -62,11 +62,13 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				return;
 			}
 			
-			localVarList.WatchItems.Clear();
 			using(new PrintTimes("Local Variables refresh")) {
 				try {
 					Utils.DoEvents(debuggedProcess);
-					var frame = !debuggedProcess.IsInExternalCode ? debuggedProcess.SelectedStackFrame : debuggedProcess.SelectedThread.MostRecentStackFrame;
+					StackFrame frame = debuggedProcess.GetCurrentExecutingFrame();
+					if (frame == null) return;
+					
+					localVarList.WatchItems.Clear();
 					foreach (var item in new StackFrameNode(frame).ChildNodes) {
 						localVarList.WatchItems.Add(item);
 					}

src/AddIns/Debugger/Debugger.AddIn/Pads/MemoryPad.cs

@@ -131,9 +131,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				console.JumpToLine(line);
 				
 			} catch (System.Exception ex) {
-				#if DEBUG
 				LoggingService.Error(ex.Message);
-				#endif
 			}
 		}
 		

src/AddIns/Debugger/Debugger.AddIn/Pads/RunningThreadsPad.cs

@@ -110,8 +110,23 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				if (debuggedProcess != null) {
 					dynamic obj = runningThreadsList.SelectedItems[0];
 					Thread thread = (Thread)(obj.Tag);
+					
+					// check for options - if these options are enabled, selecting the frame should not continue
+					if ((thread.MostRecentStackFrame == null || !thread.MostRecentStackFrame.HasSymbols) &&
+					    (debuggedProcess.Options.EnableJustMyCode || debuggedProcess.Options.StepOverNoSymbols)) {
+						MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotSwitchWithoutDecompiledCodeOptions}",
+						                           "${res:MainWindow.Windows.Debug.Threads.ThreadSwitch}");
+						return;
+					}
+					
 					debuggedProcess.SelectedThread = thread;
-					debuggedProcess.OnPaused();
+					debuggedProcess.SelectedThread.SelectedStackFrame = debuggedProcess.SelectedThread.MostRecentStackFrame;
+					if (debuggedProcess.SelectedThread.SelectedStackFrame != null) {
+						debuggedProcess.PauseSession.PausedReason = PausedReason.CurrentThreadChanged;
+						debuggedProcess.OnPaused(); // Force refresh of pads - artificial pause
+					} else {
+						MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotSwitchOnNAFrame}", "${res:MainWindow.Windows.Debug.Threads.ThreadSwitch}");
+					}
 				}
 			} else {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotSwitchWhileRunning}", "${res:MainWindow.Windows.Debug.Threads.ThreadSwitch}");

src/AddIns/Debugger/Debugger.AddIn/Service/WindowsDebugger.cs

@@ -85,15 +85,6 @@ namespace ICSharpCode.SharpDevelop.Services
 			set;
 		}
 		
-		public bool IsInExternalCode {
-			get {
-				if (debuggedProcess == null)
-					return true;
-				
-				return debuggedProcess.IsInExternalCode;
-			}
-		}
-		
 		protected virtual void OnProcessSelected(ProcessEventArgs e)
 		{
 			if (ProcessSelected != null) {
@@ -494,11 +485,11 @@ namespace ICSharpCode.SharpDevelop.Services
 				return;
 			}
 			
-			var frame = debuggedProcess.SelectedStackFrame ?? debuggedProcess.SelectedThread.MostRecentStackFrame;
+			var frame = debuggedProcess.SelectedThread.MostRecentStackFrame;
 			if (frame == null) {
 				MessageService.ShowMessage(errorCannotStepNoActiveFunction, "${res:XML.MainMenu.DebugMenu.StepInto}");
 			} else {
-				if (IsInExternalCode) {
+				if (!frame.HasSymbols) {
 					// get frame info from external code mappings
 					frame = GetStackFrame();
 				}
@@ -519,11 +510,11 @@ namespace ICSharpCode.SharpDevelop.Services
 				return;
 			}
 			
-			var frame = debuggedProcess.SelectedStackFrame ?? debuggedProcess.SelectedThread.MostRecentStackFrame;
+			var frame = debuggedProcess.SelectedThread.MostRecentStackFrame;
 			if (frame == null) {
 				MessageService.ShowMessage(errorCannotStepNoActiveFunction, "${res:XML.MainMenu.DebugMenu.StepOver}");
 			} else {
-				if (IsInExternalCode) {
+				if (!frame.HasSymbols) {
 					// get frame info from external code mappings
 					frame = GetStackFrame();
 				}
@@ -544,11 +535,11 @@ namespace ICSharpCode.SharpDevelop.Services
 				return;
 			}
 			
-			var frame = debuggedProcess.SelectedStackFrame ?? debuggedProcess.SelectedThread.MostRecentStackFrame;
+			var frame = debuggedProcess.SelectedThread.MostRecentStackFrame;
 			if (frame == null) {
 				MessageService.ShowMessage(errorCannotStepNoActiveFunction, "${res:XML.MainMenu.DebugMenu.StepInto}");
 			} else {
-				if (IsInExternalCode) {
+				if (!frame.HasSymbols) {
 					// get frame info from external code mappings
 					frame = GetStackFrame();
 				}
@@ -580,13 +571,13 @@ namespace ICSharpCode.SharpDevelop.Services
 				return null;
 			}
 			
-			var stackFrame = !debuggedProcess.IsInExternalCode ? debuggedProcess.SelectedStackFrame : debuggedProcess.SelectedThread.MostRecentStackFrame;
+			var frame = debuggedProcess.GetCurrentExecutingFrame();
 			try {
-				object data = debuggerDecompilerService.GetLocalVariableIndex(stackFrame.MethodInfo.DeclaringType.MetadataToken,
-				                                                              stackFrame.MethodInfo.MetadataToken,
+				object data = debuggerDecompilerService.GetLocalVariableIndex(frame.MethodInfo.DeclaringType.MetadataToken,
+				                                                              frame.MethodInfo.MetadataToken,
 				                                                              variableName);
 				// evaluate expression
-				return ExpressionEvaluator.Evaluate(variableName, SupportedLanguage.CSharp, stackFrame, data);
+				return ExpressionEvaluator.Evaluate(variableName, SupportedLanguage.CSharp, frame, data);
 			} catch {
 				throw;
 			}
@@ -651,7 +642,7 @@ namespace ICSharpCode.SharpDevelop.Services
 				var image = ExpressionNode.GetImageForLocalVariable(out imageName);
 				ExpressionNode expressionNode = new ExpressionNode(image, variableName, tooltipExpression);
 				expressionNode.ImageName = imageName;
-				return new DebuggerTooltipControl(logicalPosition, expressionNode) { ShowPins = !IsInExternalCode };
+				return new DebuggerTooltipControl(logicalPosition, expressionNode) { ShowPins = debuggedProcess.SelectedThread.MostRecentStackFrame.HasSymbols };
 			} catch (GetValueException) {
 				return null;
 			}
@@ -1040,20 +1031,45 @@ namespace ICSharpCode.SharpDevelop.Services
 				return;
 			
 			WorkbenchSingleton.MainWindow.Activate();
-			DebuggerService.RemoveCurrentLineMarker();
 			
-			if (!IsInExternalCode) {
+			
+			if (debuggedProcess.IsSelectedFrameForced()) {
+				if (debuggedProcess.SelectedStackFrame != null && debuggedProcess.SelectedStackFrame.HasSymbols) {
+					JumpToSourceCode();
+				} else {
+					JumpToDecompiledCode(debuggedProcess.SelectedStackFrame);
+				}
+			} else {
+				var frame = debuggedProcess.SelectedThread.MostRecentStackFrame;
+				// other pause reasons
+				if (frame.HasSymbols) {
+					JumpToSourceCode();
+				} else {
+					// use most recent stack frame because we don't have the symbols
+					JumpToDecompiledCode(debuggedProcess.SelectedThread.MostRecentStackFrame);
+				}
+			}
+		}
+
+		void JumpToSourceCode()
+		{
+			if (debuggedProcess == null || debuggedProcess.SelectedThread == null)
+				return;
+			
 			SourcecodeSegment nextStatement = debuggedProcess.NextStatement;
 			if (nextStatement != null) {
+				DebuggerService.RemoveCurrentLineMarker();
 				DebuggerService.JumpToCurrentLine(nextStatement.Filename, nextStatement.StartLine, nextStatement.StartColumn, nextStatement.EndLine, nextStatement.EndColumn);
 			}
-			} else {
-				JumpToDecompiledCode();
-			}
 		}
 		
-		void JumpToDecompiledCode()
+		void JumpToDecompiledCode(Debugger.StackFrame frame)
 		{
+			if (frame == null) {
+				LoggingService.Error("No stack frame!");
+				return;
+			}
+			
 			if (debuggerDecompilerService == null) {
 				LoggingService.Warn("No IDebuggerDecompilerService found!");
 				return;
@@ -1064,11 +1080,7 @@ namespace ICSharpCode.SharpDevelop.Services
 				LoggingService.Info("Decompiled code debugging is disabled!");
 				return;
 			}
-			
-			// use most recent stack frame because we don't have the symbols
-			var frame = debuggedProcess.SelectedThread.MostRecentStackFrame;
-			Debug.Assert(frame != null);
-			
+			DebuggerService.RemoveCurrentLineMarker();
 			// get external data
 			int typeToken = frame.MethodInfo.DeclaringType.MetadataToken;
 			int methodToken = frame.MethodInfo.MetadataToken;

src/AddIns/Debugger/Debugger.AddIn/TreeModel/ExpressionNode.cs

@@ -157,10 +157,11 @@ namespace Debugger.AddIn.TreeModel
 			Value val;
 			try {
 				var process = WindowsDebugger.DebuggedProcess;
-				var context = !process.IsInExternalCode ? process.SelectedStackFrame : process.SelectedThread.MostRecentStackFrame;
+				StackFrame frame = process.GetCurrentExecutingFrame();
+				if (frame == null) return;
 				var debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
-				object data = debugger.debuggerDecompilerService.GetLocalVariableIndex(context.MethodInfo.DeclaringType.MetadataToken, 
-				                                                                       context.MethodInfo.MetadataToken, 
+				object data = debugger.debuggerDecompilerService.GetLocalVariableIndex(frame.MethodInfo.DeclaringType.MetadataToken,
+				                                                                       frame.MethodInfo.MetadataToken,
 				                                                                       Name);
 				
 				if (expression is MemberReferenceExpression) {

src/AddIns/Debugger/Debugger.Core/NRefactory/Visitors/ExpressionEvaluator.cs

@@ -78,25 +78,11 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		public static Value Evaluate(INode code, Process context)
 		{
-			StackFrame stackFrame = null;
 			if (context.SelectedStackFrame == null && context.SelectedThread.MostRecentStackFrame == null)
 				// This can happen when needed 'dll' is missing.  This causes an exception dialog to be shown even before the applicaiton starts
 				throw new GetValueException("Can not evaluate because the process has no managed stack frames");
 			
-			if (context.SelectedStackFrame != null) {
-				if (context.SelectedThread.MostRecentStackFrame != null) {
-					if (context.SelectedStackFrame.HasSymbols && context.SelectedThread.MostRecentStackFrame.HasSymbols) 
-						stackFrame = context.SelectedStackFrame;
-					else 
-						stackFrame = context.SelectedThread.MostRecentStackFrame;
-				} else {
-					stackFrame = context.SelectedThread.MostRecentStackFrame;
-				}
-			} else {
-				stackFrame = context.SelectedThread.MostRecentStackFrame;
-			}
-			
-			return Evaluate(code, stackFrame);
+			return Evaluate(code, context.GetCurrentExecutingFrame());
 		}
 		
 		public static Value Evaluate(INode code, StackFrame context, object data = null)

src/AddIns/Debugger/Debugger.Core/PauseSession.cs

@@ -18,6 +18,7 @@ namespace Debugger
 		
 		public PausedReason PausedReason {
 			get { return pausedReason; }
+			set { pausedReason = value; }
 		}
 		
 		public PauseSession(Process process, PausedReason pausedReason)

src/AddIns/Debugger/Debugger.Core/Process.cs

@@ -134,21 +134,6 @@ namespace Debugger
 		
 		public static DebugModeFlag DebugMode { get; set; }
 		
-		public bool IsInExternalCode {
-			get {
-				if (SelectedStackFrame == null && SelectedThread.MostRecentStackFrame == null)
-					return true;
-				
-				if (SelectedStackFrame == null && SelectedThread.MostRecentStackFrame != null)
-					return true;
-				
-				if (SelectedThread.MostRecentStackFrame == null)
-					return true;
-				
-				return !(SelectedStackFrame.HasSymbols && SelectedThread.MostRecentStackFrame.HasSymbols);
-			}
-		}
-		
 		internal Process(NDebugger debugger, ICorDebugProcess corProcess, string workingDirectory)
 		{
 			this.debugger = debugger;
@@ -720,5 +705,32 @@ namespace Debugger
 		#endregion
 		
 		public event EventHandler<ModuleEventArgs> ModulesAdded;
+		
+		public StackFrame GetCurrentExecutingFrame()
+		{
+			if (IsSelectedFrameForced()) {
+				return SelectedStackFrame; // selected from callstack or threads pads
+			}
+			
+			if (SelectedStackFrame != null) {
+				if (SelectedThread.MostRecentStackFrame != null) {
+					if (SelectedStackFrame.HasSymbols && SelectedThread.MostRecentStackFrame.HasSymbols)
+						return SelectedStackFrame;
+					else
+						return SelectedThread.MostRecentStackFrame;
+				} else {
+					return SelectedThread.MostRecentStackFrame;
+				}
+			} else {
+				return SelectedThread.MostRecentStackFrame;
+			}
+		}
+		
+		public bool IsSelectedFrameForced()
+		{
+			return pauseSession.PausedReason == PausedReason.CurrentFunctionChanged ||
+				pauseSession.PausedReason == PausedReason.CurrentThreadChanged ||
+				pauseSession.PausedReason == PausedReason.EvalComplete;
+		}
 	}
 }

src/AddIns/Debugger/Debugger.Core/StackFrame.cs

@@ -193,10 +193,6 @@ namespace Debugger
 		
 		void AsyncStep(bool stepIn)
 		{
-			if (this.MethodInfo.DebugModule.HasSymbols == false && process.Options.StepOverNoSymbols) {
-				throw new DebuggerException("Unable to step. No symbols loaded.");
-			}
-			
 			int[] stepRanges;
 			if (ILRanges == null) {
 				SourcecodeSegment nextSt = NextStatement;

src/AddIns/Debugger/Debugger.Core/Thread.cs

@@ -337,9 +337,6 @@ namespace Debugger
 				return selectedStackFrame;
 			}
 			set {
-				if (value != null && !value.HasSymbols) {
-					throw new DebuggerException("SelectedFunction must have symbols");
-				}
 				selectedStackFrame = value;
 			}
 		}