Added StackFrameFormat which allows DebuggerSession to format stack trace text instead of stack trace pad

Mostly useful for VsCode Debug protocol

Author: David Karlaš

Mono.Debugging/Mono.Debugging.Client/Backtrace.cs

@@ -21,9 +21,9 @@ public Backtrace (IBacktrace serverBacktrace)
 
 			count = serverBacktrace.FrameCount;
 
-			// Get some initial frames
+			// Get first frame, which is most used(for thread location)
 			if (count > 0)
-				GetFrame (0);
+				GetFrame (0, 1);
 		}
 
 		internal void Attach (DebuggerSession session)
@@ -44,12 +44,17 @@ public int FrameCount
 		}
 
 		public StackFrame GetFrame (int n)
+		{
+			return GetFrame (n, 20);
+		}
+
+		private StackFrame GetFrame(int index, int fetchMultipleCount)
 		{
 			if (frames == null)
 				frames = new List<StackFrame>();
 
-			if (n >= frames.Count) {
-				StackFrame[] newSet = serverBacktrace.GetStackFrames(frames.Count, n + 20);
+			if (index >= frames.Count) {
+				StackFrame[] newSet = serverBacktrace.GetStackFrames(frames.Count, index + fetchMultipleCount);
 				foreach (StackFrame sf in newSet) {
 					sf.SourceBacktrace = serverBacktrace;
 					sf.Index = frames.Count;
@@ -59,7 +64,7 @@ public StackFrame GetFrame (int n)
 			}
 
 			if (frames.Count > 0)
-				return frames[System.Math.Min (System.Math.Max (0, n), frames.Count - 1)];
+				return frames[System.Math.Min (System.Math.Max (0, index), frames.Count - 1)];
 
 			return null;
 		}

Mono.Debugging/Mono.Debugging.Client/EvaluationOptions.cs

@@ -33,9 +33,9 @@ public class EvaluationOptions
 	{
 		bool allowMethodEvaluation;
 		bool allowToStringCalls;
-		
-		public static readonly char Ellipsis = '…';
-		
+
+		public const char Ellipsis = '…';
+
 		public static EvaluationOptions DefaultOptions {
 			get {
 				EvaluationOptions ops = new EvaluationOptions ();
@@ -53,57 +53,94 @@ public static EvaluationOptions DefaultOptions {
 				ops.EllipsizeStrings = true;
 				ops.EllipsizedLength = 100;
 				ops.ChunkRawStrings = false;
+				ops.StackFrameFormat = new StackFrameFormat ();
 				return ops;
 			}
 		}
-		
+
 		public EvaluationOptions Clone ()
 		{
-			return (EvaluationOptions) MemberwiseClone ();
+			var clone = (EvaluationOptions)MemberwiseClone ();
+			clone.StackFrameFormat = new StackFrameFormat (StackFrameFormat);
+			return clone;
 		}
-		
+
 		public bool ChunkRawStrings { get; set; }
-		
+
 		public bool EllipsizeStrings { get; set; }
 		public int EllipsizedLength { get; set; }
-		
+
 		public int EvaluationTimeout { get; set; }
 		public int MemberEvaluationTimeout { get; set; }
 		public bool AllowTargetInvoke { get; set; }
-		
+
 		public bool AllowMethodEvaluation {
 			get { return allowMethodEvaluation && AllowTargetInvoke; }
 			set { allowMethodEvaluation = value; }
 		}
-		
+
 		public bool AllowToStringCalls {
 			get { return allowToStringCalls && AllowTargetInvoke; }
 			set { allowToStringCalls = value; }
 		}
-		
+
 		public bool AllowDisplayStringEvaluation {
 			get { return AllowTargetInvoke; }
 		}
-		
+
 		public bool AllowDebuggerProxy {
 			get { return AllowTargetInvoke; }
 		}
-		
+
 		public bool FlattenHierarchy { get; set; }
-		
+
 		public bool GroupPrivateMembers { get; set; }
-		
+
 		public bool GroupStaticMembers { get; set; }
-		
+
 		public bool UseExternalTypeResolver { get; set; }
-		
+
 		public IntegerDisplayFormat IntegerDisplayFormat { get; set; }
-		
+
 		public string CurrentExceptionTag { get; set; }
 
 		public bool IEnumerable { get; set; }
+
+		public StackFrameFormat StackFrameFormat { get; set; }
+	}
+
+	public class StackFrameFormat
+	{
+		public bool Line { get; set; } = true;
+
+		public bool Module { get; set; } = false;
+
+		public bool ParameterNames { get; set; } = true;
+
+		public bool ParameterTypes { get; set; } = true;
+
+		public bool ParameterValues { get; set; } = false;
+
+		/// <summary>
+		/// Default is null. Which means do same as "ProjectAssembliesOnly" setting.
+		/// </summary>
+		public bool? ExternalCode { get; set; } = null;
+
+		public StackFrameFormat ()
+		{
+		}
+
+		public StackFrameFormat (StackFrameFormat copy)
+		{
+			Line = copy.Line;
+			Module = copy.Module;
+			ParameterNames = copy.ParameterNames;
+			ParameterTypes = copy.ParameterTypes;
+			ParameterValues = copy.ParameterValues;
+			ExternalCode = copy.ExternalCode;
+		}
 	}
-	
+
 	public enum IntegerDisplayFormat
 	{
 		Decimal,

Mono.Debugging/Mono.Debugging.Client/StackFrame.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text;
 using Mono.Debugging.Backend;
 
 namespace Mono.Debugging.Client
@@ -115,6 +116,57 @@ public string FullModuleName {
 		public string FullTypeName {
 			get { return fullTypeName; }
 		}
+
+		/// <summary>
+		/// Gets the full name of the stackframe. Which respects Session.EvaluationOptions.StackFrameFormat
+		/// </summary>
+		public virtual string FullStackframeText {
+			get {
+				var methodNameBuilder = new StringBuilder (this.SourceLocation.MethodName);
+				var options = session.EvaluationOptions.Clone ();
+				if (options.StackFrameFormat.ParameterValues) {
+					options.AllowMethodEvaluation = true;
+					options.AllowToStringCalls = true;
+					options.AllowTargetInvoke = true;
+				} else {
+					options.AllowMethodEvaluation = false;
+					options.AllowToStringCalls = false;
+					options.AllowTargetInvoke = false;
+				}
+
+				var args = this.GetParameters (options);
+
+				//MethodName starting with "["... it's something like [ExternalCode]
+				if (!this.SourceLocation.MethodName.StartsWith ("[", StringComparison.Ordinal)) {
+					if (options.StackFrameFormat.Module && !string.IsNullOrEmpty (this.FullModuleName)) {
+						methodNameBuilder.Insert (0, System.IO.Path.GetFileName (this.FullModuleName) + "!");
+					}
+					if (options.StackFrameFormat.ParameterTypes || options.StackFrameFormat.ParameterNames || options.StackFrameFormat.ParameterValues) {
+						methodNameBuilder.Append ("(");
+						for (int n = 0; n < args.Length; n++) {
+							if (n > 0)
+								methodNameBuilder.Append (", ");
+							if (options.StackFrameFormat.ParameterTypes) {
+								methodNameBuilder.Append (args [n].TypeName);
+								if (options.StackFrameFormat.ParameterNames)
+									methodNameBuilder.Append (" ");
+							}
+							if (options.StackFrameFormat.ParameterNames)
+								methodNameBuilder.Append (args [n].Name);
+							if (options.StackFrameFormat.ParameterValues) {
+								if (options.StackFrameFormat.ParameterTypes || options.StackFrameFormat.ParameterNames)
+									methodNameBuilder.Append (" = ");
+								var val = args [n].Value ?? "";
+								methodNameBuilder.Append (val.Replace ("\r\n", " ").Replace ("\n", " "));
+							}
+						}
+						methodNameBuilder.Append (")");
+					}
+				}
+
+				return methodNameBuilder.ToString ();
+			}
+		}
 
 		public ObjectValue[] GetLocalVariables ()
 		{