Implement natvis 'na' modifier and $T substitution

src/MIDebugEngine/Engine.Impl/Variables.cs

@@ -5,6 +5,7 @@
 using Microsoft.VisualStudio.Debugger.Interop;
 using Microsoft.VisualStudio.Debugger.Interop.DAP;
 using System;
+using Microsoft.DebugEngineHost;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -92,6 +93,18 @@ internal sealed class VariableInformation : IVariableInformation
 
         static readonly Lazy<Regex> s_addressPattern = new Lazy<Regex>(() => new Regex(@"^(0x[0-9a-fA-F]+)\b"));
 
+        static readonly Regex s_naPattern = new Regex(@"^0x[0-9a-fA-F]+\s+(.)");
+
+        internal static string StripLeadingAddress(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return value;
+            }
+
+            return s_naPattern.Replace(value, "$1");
+        }
+
         public string Address()
         {
             // ask GDB to evaluate "&expression"
@@ -238,7 +251,7 @@ internal VariableInformation(string displayName, string expr, ThreadContext ctx,
             : this(ctx, engine, thread)
         {
             // strip off formatting string
-            _strippedName = ProcessFormatSpecifiers(expr, out _format);
+            _strippedName = ProcessFormatSpecifiers(expr, out _format, out _formatHasNa);
             Name = displayName;
             IsParameter = isParameter;
             _parent = null;
@@ -250,7 +263,7 @@ internal VariableInformation(string expr, IVariableInformation parent, AD7Engine
             : this(parent.ThreadContext, engine, parent.Client)
         {
             // strip off formatting string
-            _strippedName = ProcessFormatSpecifiers(expr, out _format);
+            _strippedName = ProcessFormatSpecifiers(expr, out _format, out _formatHasNa);
             Name = displayName ?? expr;
             _parent = parent;
             VariableNodeType = NodeType.Synthetic;
@@ -261,7 +274,7 @@ internal VariableInformation(string expr, VariableInformation parent)
             : this(parent._ctx, parent._engine, parent.Client)
         {
             // strip off formatting string
-            _strippedName = ProcessFormatSpecifiers(expr, out _format);
+            _strippedName = ProcessFormatSpecifiers(expr, out _format, out _formatHasNa);
             Name = expr;
             VariableNodeType = NodeType.Root;
         }
@@ -272,6 +285,12 @@ private VariableInformation(TupleValue results, VariableInformation parent, stri
         {
             TypeName = results.TryFindString("type");
             Value = results.TryFindString("value");
+            _formatHasNa = parent._formatHasNa;
+            if (_formatHasNa)
+            {
+                Value = StripLeadingAddress(Value);
+            }
+
             Name = name ?? results.FindString("exp");
             if (results.Contains("dynamic"))
             {
@@ -375,6 +394,9 @@ public VariableInformation FindChildByName(string name)
         private DeferedFormatExpression _deferedFormatExpression;
         private IVariableInformation _parent;
         private string _format;
+        // Indicates the original format specifier included the natvis "na" modifier
+        // (used to decide whether to strip MI's leading address prefix from string values)
+        private bool _formatHasNa = false;
         private string _strippedName;  // "Name" stripped of format specifiers
         private string _fullname;
 
@@ -401,8 +423,9 @@ public enum NodeType
 
         private static Regex s_isFunction = new Regex(@".+\(.*\).*");
 
-        private string ProcessFormatSpecifiers(string exp, out string formatSpecifier)
+        private string ProcessFormatSpecifiers(string exp, out string formatSpecifier, out bool formatNa)
         {
+            formatNa = false;
             formatSpecifier = null; // will be used with -var-set-format
 
             if (EngineUtils.IsConsoleExecCmd(exp, out string _, out string _))
@@ -416,6 +439,9 @@ private string ProcessFormatSpecifiers(string exp, out string formatSpecifier)
 
             // Find the format specifier expression
             string expFS = exp.Substring(lastComma + 1).Trim();
+            // Detect whether the natvis 'na' modifier is present in the original format specifier.
+            // We must detect this before we strip modifiers below.
+            formatNa = expFS.IndexOf("na", StringComparison.Ordinal) >= 0;
 
             // Strip off modifiers that may be included together with another format specifier, e.g. 'nvoXb' is a valid format specifier, but we only care about the 'Xb' part
             // This is not quite the right fix -- really the below switch statement should be a series of if statements. But since none of the supported format specifiers
@@ -698,6 +724,10 @@ internal async Task Eval(uint radix, enum_EVALFLAGS dwFlags = 0, DAPEvalFlags dw
                             _attribsFetched = true;
                         }
                         Value = results.TryFindString("value");
+                        if (_formatHasNa)
+                        {
+                            Value = StripLeadingAddress(Value);
+                        }
                         if ((string.IsNullOrEmpty(Value) || _format != null) && !string.IsNullOrEmpty(_internalName))
                         {
                             if (_format != null)
@@ -711,6 +741,10 @@ internal async Task Eval(uint radix, enum_EVALFLAGS dwFlags = 0, DAPEvalFlags dw
                                 if (results.ResultClass == ResultClass.done)
                                 {
                                     Value = results.FindString("value");
+                                    if (_formatHasNa)
+                                    {
+                                        Value = StripLeadingAddress(Value);
+                                    }
                                 }
                                 else if (results.ResultClass == ResultClass.error)
                                 {

src/MIDebugEngine/Natvis.Impl/Natvis.cs

@@ -1283,12 +1283,16 @@ private string FormatValue(string format, IVariableInformation variable, IDictio
                     if (m.Success)
                     {
                         string rawExpr = format.Substring(i + 1, m.Length - 2);
-                        string spec = ExtractFormatSpecifier(rawExpr);
+                        string spec = ExtractFormatSpecifier(rawExpr, out bool hasNa);
                         string exprValue = GetExpressionValue(rawExpr, variable, scopedNames, intrinsics);
-                        if (spec == "sub" || spec == "su")
+                        if (spec == "sub")
                             exprValue = CleanUtf16StringValue(exprValue);
                         else if (spec == "sb")
                             exprValue = CleanAsciiStringValue(exprValue);
+                        else if (hasNa)
+                        {
+                            exprValue = VariableInformation.StripLeadingAddress(exprValue);
+                        }
                         value.Append(exprValue);
                         i += m.Length - 1;
                     }
@@ -1502,13 +1506,31 @@ internal static string ExtractFormatSpecifier(string expression)
                 .Replace("nvo", "").Replace("na", "").Replace("nr", "").Replace("nd", "");
         }
 
+        /// <summary>
+        /// Returns the format specifier from a NatVis expression (the part after the last
+        /// top-level comma), normalized the same way as
+        /// <see cref="VariableInformation.ProcessFormatSpecifiers"/>: modifiers "nvo", "na",
+        /// "nr", "nd" are stripped before returning.  Returns null when no specifier is present.
+        /// also returns whether modifier 'na' was there via the out parameter
+        /// </summary>
+        internal static string ExtractFormatSpecifier(string expression, out bool hasNa)
+        {
+            hasNa = false;
+            int commaPos = FindLastTopLevelComma(expression);
+            if (commaPos < 0) return null;
+
+            string tail = expression.Substring(commaPos + 1).Trim();
+            hasNa = tail.IndexOf("na", StringComparison.Ordinal) >= 0;
+
+            return tail
+                .Replace("nvo", "").Replace("na", "").Replace("nr", "").Replace("nd", "");
+        }
+
         /// <summary>
         /// Cleans up the raw value that GDB/LLDB returns for a <c>const char16_t*</c>
         /// expression (i.e. one evaluated with the <c>,sub</c> / <c>,su</c> format specifier).
         /// GDB and LLDB both prefix the string with the pointer address, e.g.
         ///   <c>0x00007fff5fbff6c0 u"Hello"</c>
-        /// This method strips the address and the surrounding <c>u"…"</c> quotes so that
-        /// the NatVis DisplayString shows just the string content.
         /// </summary>
         internal static string CleanUtf16StringValue(string value)
         {
@@ -1531,9 +1553,6 @@ internal static string CleanUtf16StringValue(string value)
         /// (i.e. one evaluated with the <c>,sb</c> format specifier).
         /// GDB and LLDB prefix the string with the pointer address, e.g.
         ///   <c>0x00007fff5fbff6c0 "Hello"</c>
-        /// This method strips the address and the surrounding <c>"…"</c> quotes so that
-        /// the NatVis DisplayString shows just the string content (matching VS behaviour,
-        /// where <c>{ptr,sb}</c> evaluates to bare text without quotes).
         /// </summary>
         internal static string CleanAsciiStringValue(string value)
         {

src/MIDebugEngineUnitTests/NatvisFormatSpecifierTest.cs

@@ -15,33 +15,67 @@ public class NatvisFormatSpecifierTest
         [Fact]
         public void ExtractFormatSpecifier_Sub_Extracted()
         {
-            Assert.Equal("sub", Natvis.ExtractFormatSpecifier("schemeStr(),sub"));
+            Assert.Equal("sub", Natvis.ExtractFormatSpecifier("schemeStr(),sub", out _));
         }
 
         [Fact]
         public void ExtractFormatSpecifier_Decimal_Extracted()
         {
-            Assert.Equal("d", Natvis.ExtractFormatSpecifier("year(),d"));
+            Assert.Equal("d", Natvis.ExtractFormatSpecifier("year(),d", out _));
         }
 
         [Fact]
         public void ExtractFormatSpecifier_NoSpecifier_ReturnsNull()
         {
-            Assert.Null(Natvis.ExtractFormatSpecifier("cspec == 1"));
+            Assert.Null(Natvis.ExtractFormatSpecifier("cspec == 1", out _));
         }
 
         [Fact]
         public void ExtractFormatSpecifier_NvoModifierStripped()
         {
             // "nvoXb": strip "nvo" modifier, result is "Xb"
-            Assert.Equal("Xb", Natvis.ExtractFormatSpecifier("data1,nvoXb"));
+            Assert.Equal("Xb", Natvis.ExtractFormatSpecifier("data1,nvoXb", out _));
         }
 
         [Fact]
         public void ExtractFormatSpecifier_NaModifierStripped()
         {
             // "view(RecZone)na": strip "na", result is "view(RecZone)"
-            Assert.Equal("view(RecZone)", Natvis.ExtractFormatSpecifier("this,view(RecZone)na"));
+            Assert.Equal("view(RecZone)", Natvis.ExtractFormatSpecifier("this,view(RecZone)na", out bool hasNa));
+            Assert.True(hasNa);
+        }
+
+        [Fact]
+        public void ExtractFormatSpecifier_HasTemplateParameter()
+        {
+            // Template parameters should be detected but not substituted by ExtractFormatSpecifier
+            // (they're substituted by ReplaceNamesInExpression)
+            string spec = Natvis.ExtractFormatSpecifier("myVector,sub");
+            Assert.Equal("sub", spec);
+        }
+
+        [Fact]
+        public void ExtractFormatSpecifier_WithNaModifier_HasNaIsTrue()
+        {
+            string spec = Natvis.ExtractFormatSpecifier("someExpr,na", out bool hasNa);
+            Assert.Equal("", spec);
+            Assert.True(hasNa);
+        }
+
+        [Fact]
+        public void ExtractFormatSpecifier_WithNaAndFormat_HasNaIsTrueAndSpecReturned()
+        {
+            string spec = Natvis.ExtractFormatSpecifier("myString,subna", out bool hasNa);
+            Assert.Equal("sub", spec);
+            Assert.True(hasNa);
+        }
+
+        [Fact]
+        public void ExtractFormatSpecifier_WithoutNaModifier_HasNaIsFalse()
+        {
+            string spec = Natvis.ExtractFormatSpecifier("myString,sub", out bool hasNa);
+            Assert.Equal("sub", spec);
+            Assert.False(hasNa);
         }
 
         // -- CleanUtf16StringValue --------------------------------------------