From 7a2debb985e57700fd409f86dff1664bc8e40f70 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Tue, 5 Nov 2024 12:09:44 -0800
Subject: [PATCH 1/5] EE: Support compact name in
 IDkmLanguageInstructionDecoder.GetMethodName() implementation

---
 eng/Directory.Packages.props                  |   4 +-
 .../CSharpInstructionDecoder.cs               |   5 +
 .../InstructionDecoderTests.cs                | 162 ++++++++++++++++-
 .../ExpressionCompiler/InstructionDecoder.cs  |   3 +
 .../LanguageInstructionDecoder.cs             |  16 +-
 .../VisualBasicInstructionDecoder.vb          |   5 +-
 .../InstructionDecoderTests.vb                | 163 ++++++++++++++++--
 7 files changed, 332 insertions(+), 26 deletions(-)

diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 67159fa6d5ecc..22491a15a8f7f 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -122,8 +122,8 @@
       VS Debugger
     -->
     <PackageVersion Include="Microsoft.VisualStudio.Debugger.Contracts" Version="17.12.0-beta.24403.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Debugger.Engine-implementation" Version="17.13.1100701-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Debugger.Metadata-implementation" Version="17.13.1100701-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Debugger.Engine-implementation" Version="17.13.1110101-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Debugger.Metadata-implementation" Version="17.13.1110101-preview" />
 
     <!--
       VS .NET Runtime
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
index ffb9693712bc5..a12de0bd967c6 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
@@ -34,6 +34,11 @@ private CSharpInstructionDecoder()
             AddMemberOptions(SymbolDisplayMemberOptions.IncludeParameters).
             WithParameterOptions(SymbolDisplayParameterOptions.IncludeType);
 
+        internal override string GetCompactName(MethodSymbol method)
+        {
+            return (method.AssociatedSymbol ?? method).Name;
+        }
+
         internal override void AppendFullName(StringBuilder builder, MethodSymbol method)
         {
             var displayFormat = method.MethodKind is MethodKind.PropertyGet or MethodKind.PropertySet
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
index ab55a95a123f1..63a882cd3b104 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
@@ -7,9 +7,9 @@
 using System;
 using System.Diagnostics;
 using System.Linq;
-using System.Reflection.Metadata.Ecma335;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
+using Microsoft.CodeAnalysis.CSharp.UnitTests;
 using Microsoft.CodeAnalysis.ExpressionEvaluator;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -402,6 +402,144 @@ class C
             Assert.Equal("System.Action<System.Func<object>>", GetReturnTypeName(source, "C.M1", [typeof(object)]));
         }
 
+        [Fact]
+        public void GetCompactName_Members()
+        {
+            var source = """
+                using System;
+                namespace System.Runtime.CompilerServices
+                {
+                    public class IsExternalInit { }
+                }
+                class C
+                {
+                    static C() { }
+                    C(int x) { }
+                    ~C() { }
+                    object F() => null;
+                    object P1 { get; }
+                    object P2 { set { } }
+                    object P3 { init { } }
+                    object this[int i] { get { return null; } set { } }
+                    event EventHandler E;
+                    public static C operator+(C c) => c;
+                    public static implicit operator int(C c) => 0;
+                    public static explicit operator string(C c) => "";
+                }
+                static class E
+                {
+                    static void M(this string x) { }
+                }
+                """;
+            var compilation = CreateCompilation(source);
+            var containingType = compilation.GlobalNamespace.GetTypeMember("C");
+            VerifyMethodName(compilation, containingType.GetMethod("F"), "C.F()", "F");
+            VerifyMethodName(compilation, containingType.GetMethod("get_P1"), "C.P1.get()", "P1");
+            VerifyMethodName(compilation, containingType.GetMethod("set_P2"), "C.P2.set(value)", "P2");
+            VerifyMethodName(compilation, containingType.GetMethod("set_P3"), "C.P3.init(value)", "P3");
+            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.this[int].get(i)", "this[]");
+            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.this[int].set(i, value)", "this[]");
+            VerifyMethodName(compilation, containingType.GetMethod("add_E"), "C.E.add(value)", "E");
+            VerifyMethodName(compilation, containingType.GetMethod("remove_E"), "C.E.remove(value)", "E");
+            VerifyMethodName(compilation, compilation.GlobalNamespace.GetTypeMember("E").GetMethod("M"), "E.M(x)", "M");
+            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.C()", ".cctor");
+            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.C(x)", ".ctor");
+            VerifyMethodName(compilation, containingType.GetMethod("Finalize"), "C.~C()", "Finalize");
+            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.operator +(c)", "op_UnaryPlus");
+            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.implicit operator int(c)", "op_Implicit");
+            VerifyMethodName(compilation, containingType.GetMethod("op_Explicit"), "C.explicit operator string(c)", "op_Explicit");
+        }
+
+        [Fact]
+        public void GetCompactName_GenericMethod()
+        {
+            var source = """
+                using System;
+                class A<T>
+                {
+                    public struct B<U>
+                    {
+                        static void M<V>(T t, U u, V v) { }
+                    }
+                }
+                """;
+            var compilation = CreateCompilation(source);
+            var instructionDecoder = CSharpInstructionDecoder.Instance;
+            var method = GetConstructedMethod(
+                compilation,
+                (PEMethodSymbol)compilation.GlobalNamespace.GetTypeMember("A").GetTypeMember("B").GetMethod("M"),
+                ["object", "int", "string"],
+                instructionDecoder);
+            var actualName = instructionDecoder.GetName(method, includeParameterTypes: false, includeParameterNames: true);
+            var actualCompactName = instructionDecoder.GetCompactName(method);
+            Assert.Equal("A<object>.B<int>.M<string>(t, u, v)", actualName);
+            Assert.Equal("M", actualCompactName);
+        }
+
+        [Fact]
+        public void GetCompactName_ExplicitImplementation()
+        {
+            var source = """
+                using System;
+                interface I
+                {
+                    object F();
+                    object P { get; }
+                    object this[int i] { get; }
+                    event EventHandler E;
+                }
+                class C : I
+                {
+                    object I.F() => null;
+                    object I.P => null;
+                    object I.this[int i] => null;
+                    event EventHandler I.E { add { } remove { } }
+                }
+                """;
+            var compilation = CreateCompilation(source);
+            var containingType = compilation.GlobalNamespace.GetTypeMember("C");
+            VerifyMethodName(compilation, containingType.GetMethod("I.F"), "C.I.F()", "I.F");
+            VerifyMethodName(compilation, containingType.GetMethod("I.get_P"), "C.I.P.get()", "I.P");
+            VerifyMethodName(compilation, containingType.GetMethod("I.get_Item"), "C.I.get_Item(i)", "I.get_Item");
+            VerifyMethodName(compilation, containingType.GetMethod("I.add_E"), "C.I.E.add(value)", "I.E");
+        }
+
+        [Fact]
+        public void GetCompactName_NestedFunctions()
+        {
+            var source = """
+                using System;
+                class Program
+                {
+                    static void Main(string[] args)
+                    {
+                        Func<string> f1 = () => args[0];
+                        string f2() => args[1];
+                        _ = f1();
+                        _ = f2();
+                    }
+                }
+                """;
+            var compilation = CreateCompilation(source);
+            var containingType = compilation.GlobalNamespace.GetTypeMember("Program").GetTypeMember("<>c__DisplayClass0_0");
+            VerifyMethodName(compilation, containingType.GetMethod("<Main>b__0"), "Program.Main.AnonymousMethod__0()", "<Main>b__0");
+            VerifyMethodName(compilation, containingType.GetMethod("<Main>g__f2|1"), "Program.Main.__f2|1()", "<Main>g__f2|1");
+        }
+
+        private void VerifyMethodName(CSharpCompilation compilation, MethodSymbol method, string expectedName, string expectedCompactName)
+        {
+            var instructionDecoder = CSharpInstructionDecoder.Instance;
+            method = GetConstructedMethod(
+                compilation,
+                (PEMethodSymbol)method,
+                null,
+                instructionDecoder);
+            var actualName = instructionDecoder.GetName(method, includeParameterTypes: false, includeParameterNames: true);
+            var actualCompactName = instructionDecoder.GetCompactName(method);
+            Assert.Equal(expectedName, actualName);
+            Assert.Equal(expectedCompactName, actualCompactName);
+        }
+
         private string GetName(string source, string methodName, DkmVariableInfoFlags argumentFlags, Type[] typeArguments = null, string[] argumentValues = null)
         {
             var serializedTypeArgumentNames = typeArguments?.Select(t => t?.AssemblyQualifiedName).ToArray();
@@ -414,7 +552,12 @@ private string GetName(string source, string methodName, DkmVariableInfoFlags ar
                 "Unexpected argumentFlags", "argumentFlags = {0}", argumentFlags);
 
             var instructionDecoder = CSharpInstructionDecoder.Instance;
-            var method = GetConstructedMethod(source, methodName, typeArguments, instructionDecoder);
+            var compilation = CreateCompilation(source);
+            var method = GetConstructedMethod(
+                compilation,
+                (PEMethodSymbol)GetMethodOrTypeBySignature(compilation, methodName),
+                typeArguments,
+                instructionDecoder);
 
             var includeParameterTypes = argumentFlags.Includes(DkmVariableInfoFlags.Types);
             var includeParameterNames = argumentFlags.Includes(DkmVariableInfoFlags.Names);
@@ -435,20 +578,27 @@ private string GetReturnTypeName(string source, string methodName, Type[] typeAr
         {
             var instructionDecoder = CSharpInstructionDecoder.Instance;
             var serializedTypeArgumentNames = typeArguments?.Select(t => t?.AssemblyQualifiedName).ToArray();
-            var method = GetConstructedMethod(source, methodName, serializedTypeArgumentNames, instructionDecoder);
+            var compilation = CreateCompilation(source);
+            var method = GetConstructedMethod(
+                compilation,
+                (PEMethodSymbol)GetMethodOrTypeBySignature(compilation, methodName),
+                serializedTypeArgumentNames,
+                instructionDecoder);
 
             return instructionDecoder.GetReturnTypeName(method);
         }
 
-        private MethodSymbol GetConstructedMethod(string source, string methodName, string[] serializedTypeArgumentNames, CSharpInstructionDecoder instructionDecoder)
+        private CSharpCompilation CreateCompilation(string source)
         {
             var compilation = CreateCompilationWithMscorlib461(source, options: TestOptions.DebugDll, assemblyName: nameof(InstructionDecoderTests));
             var runtime = CreateRuntimeInstance(compilation);
             var moduleInstances = runtime.Modules;
             var blocks = moduleInstances.SelectAsArray(m => m.MetadataBlock);
-            compilation = blocks.ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies);
-            var frame = (PEMethodSymbol)GetMethodOrTypeBySignature(compilation, methodName);
+            return blocks.ToCompilation(default(Guid), MakeAssemblyReferencesKind.AllAssemblies);
+        }
 
+        private MethodSymbol GetConstructedMethod(CSharpCompilation compilation, PEMethodSymbol frame, string[] serializedTypeArgumentNames, CSharpInstructionDecoder instructionDecoder)
+        {
             // Once we have the method token, we want to look up the method (again)
             // using the same helper as the product code.  This helper will also map
             // async/iterator "MoveNext" methods to the original source method.
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
index c8288ebf1beb5..08f82d0108431 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Symbols;
 using Microsoft.VisualStudio.Debugger.Clr;
+using Microsoft.VisualStudio.Debugger.Evaluation;
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator
 {
@@ -36,6 +37,8 @@ internal MakeAssemblyReferencesKind GetMakeAssemblyReferencesKind()
             return _useReferencedAssembliesOnly ? MakeAssemblyReferencesKind.AllReferences : MakeAssemblyReferencesKind.AllAssemblies;
         }
 
+        internal abstract string GetCompactName(TMethodSymbol method);
+
         internal abstract void AppendFullName(StringBuilder builder, TMethodSymbol method);
 
         internal virtual void AppendParameterTypeName(StringBuilder builder, IParameterSymbol parameter)
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs
index 69429ca46ff4e..e8a401155f8ca 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/LanguageInstructionDecoder.cs
@@ -38,16 +38,24 @@ string IDkmLanguageInstructionDecoder.GetMethodName(DkmLanguageInstructionAddres
                 // but it was ignored.  Furthermore, it's not clear what FullNames would mean with respect
                 // to argument names in C# or Visual Basic.  For consistency with the old behavior, we'll
                 // just ignore the flag as well.
-                Debug.Assert((argumentFlags & (DkmVariableInfoFlags.FullNames | DkmVariableInfoFlags.Names | DkmVariableInfoFlags.Types)) == argumentFlags,
+                Debug.Assert((argumentFlags & (DkmVariableInfoFlags.FullNames | DkmVariableInfoFlags.Names | DkmVariableInfoFlags.Types | DkmVariableInfoFlags.CompactName)) == argumentFlags,
                     $"Unexpected argumentFlags '{argumentFlags}'");
 
                 var instructionAddress = (DkmClrInstructionAddress)languageInstructionAddress.Address;
                 var compilation = _instructionDecoder.GetCompilation(instructionAddress.ModuleInstance);
                 var method = _instructionDecoder.GetMethod(compilation, instructionAddress);
-                var includeParameterTypes = argumentFlags.Includes(DkmVariableInfoFlags.Types);
-                var includeParameterNames = argumentFlags.Includes(DkmVariableInfoFlags.Names);
 
-                return _instructionDecoder.GetName(method, includeParameterTypes, includeParameterNames);
+                if (argumentFlags.Includes(DkmVariableInfoFlags.CompactName))
+                {
+                    return _instructionDecoder.GetCompactName(method);
+                }
+                else
+                {
+                    var includeParameterTypes = argumentFlags.Includes(DkmVariableInfoFlags.Types);
+                    var includeParameterNames = argumentFlags.Includes(DkmVariableInfoFlags.Names);
+
+                    return _instructionDecoder.GetName(method, includeParameterTypes, includeParameterNames);
+                }
             }
             catch (NotImplementedMetadataException)
             {
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
index 6ca1193868961..d909089526eb9 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
@@ -8,7 +8,6 @@ Imports System.Reflection.Metadata.Ecma335
 Imports Microsoft.CodeAnalysis.ExpressionEvaluator
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
-Imports Microsoft.VisualStudio.Debugger
 Imports Microsoft.VisualStudio.Debugger.Clr
 Imports System.Text
 
@@ -29,6 +28,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
         Private Sub New()
         End Sub
 
+        Friend Overrides Function GetCompactName(method As MethodSymbol) As String
+            Return If(method.AssociatedSymbol, method).Name
+        End Function
+
         Friend Overrides Sub AppendFullName(builder As StringBuilder, method As MethodSymbol)
             Dim parts = method.ToDisplayParts(DisplayFormat)
             Dim numParts = parts.Length
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
index 972b92a73f49e..93b92d687912c 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
@@ -2,7 +2,6 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports System.Reflection.Metadata.Ecma335
 Imports Microsoft.CodeAnalysis.ExpressionEvaluator
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
@@ -464,6 +463,133 @@ End Class"
             Assert.Equal("System.Action(Of System.Func(Of Object))", GetReturnTypeName(source, "C.M1", typeArguments:={GetType(Object)}))
         End Sub
 
+        <Fact>
+        Public Sub GetCompactName_Members()
+            Dim source = "
+Imports System
+Imports System.Runtime.CompilerServices
+Class C
+    Shared Sub New()
+    End Sub
+    Sub New(x As Integer)
+    End Sub
+    Function F() As Object
+        Return Nothing
+    End Function
+    Property P As Object
+        Get
+            Return Nothing
+        End Get
+        Set
+        End Set
+    End Property
+    Default Property Item(i As Integer) As Object
+        Get
+            Return Nothing
+        End Get
+        Set
+        End Set
+    End Property
+    Event E As EventHandler
+    Shared Operator +(c As C) As C
+        Return Nothing
+    End Operator
+    Shared Widening Operator CType(c As C) As String
+        Return Nothing
+    End Operator
+End Class
+Module E
+    <Extension>
+    Sub M(x As String)
+    End Sub
+End Module"
+            Dim compilation = CreateCompilation(source)
+            Dim containingType = compilation.GlobalNamespace.GetTypeMember("C")
+            VerifyMethodName(compilation, containingType.GetMethod("F"), "C.F()", "F")
+            VerifyMethodName(compilation, containingType.GetMethod("get_P"), "C.get_P()", "P")
+            VerifyMethodName(compilation, containingType.GetMethod("set_P"), "C.set_P(Value)", "P")
+            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.get_Item(i)", "Item")
+            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.set_Item(i, Value)", "Item")
+            VerifyMethodName(compilation, containingType.GetMethod("add_E"), "C.E(obj)", "E")
+            VerifyMethodName(compilation, containingType.GetMethod("remove_E"), "C.E(obj)", "E")
+            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.New()", ".cctor")
+            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.New(x)", ".ctor")
+            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.+(c)", "op_UnaryPlus")
+            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.CType(c)", "op_Implicit")
+            VerifyMethodName(compilation, compilation.GlobalNamespace.GetTypeMember("E").GetMethod("M"), "E.M(x)", "M")
+        End Sub
+
+        <Fact>
+        Public Sub GetCompactName_GenericMethod()
+            Dim source = "
+Imports System
+Class A(Of T)
+    Public Structure B(Of U)
+        Sub M(Of V)(x As T, y As U, z As V)
+        End Sub
+    End Structure
+End Class"
+            Dim compilation = CreateCompilation(source)
+            Dim instructionDecoder = VisualBasicInstructionDecoder.Instance
+            Dim method = GetConstructedMethod(
+                compilation,
+                DirectCast(compilation.GlobalNamespace.GetTypeMember("A").GetTypeMember("B").GetMethod("M"), PEMethodSymbol),
+                {"Object", "Integer", "String"},
+                instructionDecoder)
+            Dim actualName = instructionDecoder.GetName(method, includeParameterTypes:=False, includeParameterNames:=True)
+            Dim actualCompactName = instructionDecoder.GetCompactName(method)
+            Assert.Equal("A(Of Object).B(Of Integer).M(Of String)(x, y, z)", actualName)
+            Assert.Equal("M", actualCompactName)
+        End Sub
+
+        <Fact>
+        Public Sub GetCompactName_ExplicitImplementation()
+            Dim source = "
+Imports System
+Interface I
+    Function F() As Object
+    Property P As Object
+    Default ReadOnly Property Item(i As Integer) As Object
+End Interface
+Class C
+    Implements I
+    Function I_F0() As Object Implements I.F
+        Return Nothing
+    End Function
+    Property I_P0 As Object Implements I.P
+        Get
+            Return Nothing
+        End Get
+        Set
+        End Set
+    End Property
+    Default ReadOnly Property I_Item0(i As Integer) As Object Implements I.Item
+        Get
+            Return Nothing
+        End Get
+    End Property
+End Class"
+            Dim compilation = CreateCompilation(source)
+            Dim containingType = compilation.GlobalNamespace.GetTypeMember("C")
+            VerifyMethodName(compilation, containingType.GetMethod("I_F0"), "C.I_F0()", "I_F0")
+            VerifyMethodName(compilation, containingType.GetMethod("get_I_P0"), "C.get_I_P0()", "I_P0")
+            VerifyMethodName(compilation, containingType.GetMethod("set_I_P0"), "C.set_I_P0(Value)", "I_P0")
+            VerifyMethodName(compilation, containingType.GetMethod("get_I_Item0"), "C.get_I_Item0(i)", "I_Item0")
+        End Sub
+
+        Private Sub VerifyMethodName(compilation As VisualBasicCompilation, method As MethodSymbol, expectedName As String, expectedCompactName As String)
+            Dim instructionDecoder = VisualBasicInstructionDecoder.Instance
+            method = GetConstructedMethod(
+                compilation,
+                DirectCast(method, PEMethodSymbol),
+                Nothing,
+                instructionDecoder)
+            Dim actualName = instructionDecoder.GetName(method, includeParameterTypes:=False, includeParameterNames:=True)
+            Dim actualCompactName = instructionDecoder.GetCompactName(method)
+            Assert.Equal(expectedName, actualName)
+            Assert.Equal(expectedCompactName, actualCompactName)
+        End Sub
+
         Private Function GetName(source As String, methodName As String, argumentFlags As DkmVariableInfoFlags, Optional typeArguments() As Type = Nothing, Optional argumentValues() As String = Nothing) As String
             Dim serializedTypeArgumentNames = typeArguments?.Select(Function(t) t?.AssemblyQualifiedName).ToArray()
             Return GetName(source, methodName, argumentFlags, serializedTypeArgumentNames, argumentValues)
@@ -474,7 +600,12 @@ End Class"
                 "Unexpected argumentFlags", "argumentFlags = {0}", argumentFlags)
 
             Dim instructionDecoder = VisualBasicInstructionDecoder.Instance
-            Dim method = GetConstructedMethod(source, methodName, typeArguments, instructionDecoder)
+            Dim compilation = CreateCompilation(source)
+            Dim method = GetConstructedMethod(
+                compilation,
+                DirectCast(GetMethodOrTypeBySignature(compilation, methodName), PEMethodSymbol),
+                typeArguments,
+                instructionDecoder)
 
             Dim includeParameterTypes = argumentFlags.Includes(DkmVariableInfoFlags.Types)
             Dim includeParameterNames = argumentFlags.Includes(DkmVariableInfoFlags.Names)
@@ -492,15 +623,7 @@ End Class"
             Return name
         End Function
 
-        Private Function GetReturnTypeName(source As String, methodName As String, Optional typeArguments() As Type = Nothing) As String
-            Dim instructionDecoder = VisualBasicInstructionDecoder.Instance
-            Dim serializedTypeArgumentNames = typeArguments?.Select(Function(t) t?.AssemblyQualifiedName).ToArray()
-            Dim method = GetConstructedMethod(source, methodName, serializedTypeArgumentNames, instructionDecoder)
-
-            Return instructionDecoder.GetReturnTypeName(method)
-        End Function
-
-        Private Function GetConstructedMethod(source As String, methodName As String, serializedTypeArgumentNames() As String, instructionDecoder As VisualBasicInstructionDecoder) As MethodSymbol
+        Private Function CreateCompilation(source As String) As VisualBasicCompilation
             Dim compilation = CreateEmptyCompilationWithReferences(
                 {VisualBasicSyntaxTree.ParseText(source)},
                 references:={MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929},
@@ -509,9 +632,23 @@ End Class"
             Dim runtime = CreateRuntimeInstance(compilation)
             Dim moduleInstances = runtime.Modules
             Dim blocks = moduleInstances.SelectAsArray(Function(m) m.MetadataBlock)
-            compilation = blocks.ToCompilation()
-            Dim frame = DirectCast(GetMethodOrTypeBySignature(compilation, methodName), PEMethodSymbol)
+            Return blocks.ToCompilation()
+        End Function
+
+        Private Function GetReturnTypeName(source As String, methodName As String, Optional typeArguments() As Type = Nothing) As String
+            Dim instructionDecoder = VisualBasicInstructionDecoder.Instance
+            Dim serializedTypeArgumentNames = typeArguments?.Select(Function(t) t?.AssemblyQualifiedName).ToArray()
+            Dim compilation = CreateCompilation(source)
+            Dim method = GetConstructedMethod(
+                compilation,
+                DirectCast(GetMethodOrTypeBySignature(compilation, methodName), PEMethodSymbol),
+                serializedTypeArgumentNames,
+                instructionDecoder)
+
+            Return instructionDecoder.GetReturnTypeName(method)
+        End Function
 
+        Private Function GetConstructedMethod(compilation As VisualBasicCompilation, frame As PEMethodSymbol, serializedTypeArgumentNames() As String, instructionDecoder As VisualBasicInstructionDecoder) As MethodSymbol
             ' Once we have the method token, we want to look up the method (again)
             ' using the same helper as the product code.  This helper will also map
             ' async/ iterator "MoveNext" methods to the original source method.

From 31b23b097ece61b77318f19c5b17fd3e3f41d3c1 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Thu, 7 Nov 2024 14:44:11 -0800
Subject: [PATCH 2/5] Use display name

---
 .../CSharpInstructionDecoder.cs                  |  3 ++-
 .../InstructionDecoderTests.cs                   | 16 ++++++++--------
 .../ExpressionCompiler/InstructionDecoder.cs     |  6 ++++++
 .../VisualBasicInstructionDecoder.vb             |  3 ++-
 .../InstructionDecoderTests.vb                   |  8 ++++----
 5 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
index a12de0bd967c6..5d42c47029f54 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
@@ -36,7 +36,8 @@ private CSharpInstructionDecoder()
 
         internal override string GetCompactName(MethodSymbol method)
         {
-            return (method.AssociatedSymbol ?? method).Name;
+            var symbol = method.AssociatedSymbol ?? method;
+            return symbol.ToDisplayString(CompactNameFormat);
         }
 
         internal override void AppendFullName(StringBuilder builder, MethodSymbol method)
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
index 63a882cd3b104..b983f3322ef38 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
@@ -437,17 +437,17 @@ static void M(this string x) { }
             VerifyMethodName(compilation, containingType.GetMethod("get_P1"), "C.P1.get()", "P1");
             VerifyMethodName(compilation, containingType.GetMethod("set_P2"), "C.P2.set(value)", "P2");
             VerifyMethodName(compilation, containingType.GetMethod("set_P3"), "C.P3.init(value)", "P3");
-            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.this[int].get(i)", "this[]");
-            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.this[int].set(i, value)", "this[]");
+            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.this[int].get(i)", "this");
+            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.this[int].set(i, value)", "this");
             VerifyMethodName(compilation, containingType.GetMethod("add_E"), "C.E.add(value)", "E");
             VerifyMethodName(compilation, containingType.GetMethod("remove_E"), "C.E.remove(value)", "E");
             VerifyMethodName(compilation, compilation.GlobalNamespace.GetTypeMember("E").GetMethod("M"), "E.M(x)", "M");
-            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.C()", ".cctor");
-            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.C(x)", ".ctor");
-            VerifyMethodName(compilation, containingType.GetMethod("Finalize"), "C.~C()", "Finalize");
-            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.operator +(c)", "op_UnaryPlus");
-            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.implicit operator int(c)", "op_Implicit");
-            VerifyMethodName(compilation, containingType.GetMethod("op_Explicit"), "C.explicit operator string(c)", "op_Explicit");
+            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.C()", "C");
+            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.C(x)", "C");
+            VerifyMethodName(compilation, containingType.GetMethod("Finalize"), "C.~C()", "~C");
+            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.operator +(c)", "operator +");
+            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.implicit operator int(c)", "implicit operator int");
+            VerifyMethodName(compilation, containingType.GetMethod("op_Explicit"), "C.explicit operator string(c)", "explicit operator string");
         }
 
         [Fact]
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
index 08f82d0108431..99301f6629e71 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
@@ -24,6 +24,12 @@ internal abstract class InstructionDecoder<TCompilation, TMethodSymbol, TModuleS
             memberOptions: SymbolDisplayMemberOptions.IncludeContainingType | SymbolDisplayMemberOptions.IncludeExplicitInterface,
             miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
 
+        internal static readonly SymbolDisplayFormat CompactNameFormat = new SymbolDisplayFormat(
+            typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,
+            genericsOptions: SymbolDisplayGenericsOptions.None,
+            memberOptions: SymbolDisplayMemberOptions.IncludeExplicitInterface,
+            miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
+
         private readonly bool _useReferencedAssembliesOnly;
 
         internal InstructionDecoder()
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
index d909089526eb9..f4e8c8f128f3e 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/VisualBasicInstructionDecoder.vb
@@ -29,7 +29,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
         End Sub
 
         Friend Overrides Function GetCompactName(method As MethodSymbol) As String
-            Return If(method.AssociatedSymbol, method).Name
+            Dim symbol = If(method.AssociatedSymbol, method)
+            Return symbol.ToDisplayString(CompactNameFormat)
         End Function
 
         Friend Overrides Sub AppendFullName(builder As StringBuilder, method As MethodSymbol)
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
index 93b92d687912c..97f7db63389c2 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/InstructionDecoderTests.vb
@@ -512,10 +512,10 @@ End Module"
             VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.set_Item(i, Value)", "Item")
             VerifyMethodName(compilation, containingType.GetMethod("add_E"), "C.E(obj)", "E")
             VerifyMethodName(compilation, containingType.GetMethod("remove_E"), "C.E(obj)", "E")
-            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.New()", ".cctor")
-            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.New(x)", ".ctor")
-            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.+(c)", "op_UnaryPlus")
-            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.CType(c)", "op_Implicit")
+            VerifyMethodName(compilation, containingType.GetMethod(".cctor"), "C.New()", "New")
+            VerifyMethodName(compilation, containingType.GetMethod(".ctor"), "C.New(x)", "New")
+            VerifyMethodName(compilation, containingType.GetMethod("op_UnaryPlus"), "C.+(c)", "+")
+            VerifyMethodName(compilation, containingType.GetMethod("op_Implicit"), "C.CType(c)", "CType")
             VerifyMethodName(compilation, compilation.GlobalNamespace.GetTypeMember("E").GetMethod("M"), "E.M(x)", "M")
         End Sub
 

From 5c88f11589b06aa60593f489b75e82ad8fa3edae Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Thu, 14 Nov 2024 13:02:39 -0800
Subject: [PATCH 3/5] Ununsed using

---
 .../Core/Source/ExpressionCompiler/InstructionDecoder.cs         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
index 99301f6629e71..ec86985d75dec 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/InstructionDecoder.cs
@@ -7,7 +7,6 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Symbols;
 using Microsoft.VisualStudio.Debugger.Clr;
-using Microsoft.VisualStudio.Debugger.Evaluation;
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator
 {

From abb3fb03929a71130391e9858effd3bedb4ef2de Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Thu, 14 Nov 2024 13:31:35 -0800
Subject: [PATCH 4/5] Use 'this[]' for indexers

---
 .../Source/ExpressionCompiler/CSharpInstructionDecoder.cs | 8 +++++++-
 .../Test/ExpressionCompiler/InstructionDecoderTests.cs    | 4 ++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
index 5d42c47029f54..b4bf74bf56d7f 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
@@ -34,10 +34,16 @@ private CSharpInstructionDecoder()
             AddMemberOptions(SymbolDisplayMemberOptions.IncludeParameters).
             WithParameterOptions(SymbolDisplayParameterOptions.IncludeType);
 
+        internal static readonly SymbolDisplayFormat s_indexerCompactNameFormat = CompactNameFormat.
+            WithMemberOptions(SymbolDisplayMemberOptions.IncludeParameters);
+
         internal override string GetCompactName(MethodSymbol method)
         {
             var symbol = method.AssociatedSymbol ?? method;
-            return symbol.ToDisplayString(CompactNameFormat);
+            var format = symbol is PropertySymbol { IsIndexer: true } ?
+                s_indexerCompactNameFormat :
+                CompactNameFormat;
+            return symbol.ToDisplayString(format);
         }
 
         internal override void AppendFullName(StringBuilder builder, MethodSymbol method)
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
index b983f3322ef38..296b53939144b 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/InstructionDecoderTests.cs
@@ -437,8 +437,8 @@ static void M(this string x) { }
             VerifyMethodName(compilation, containingType.GetMethod("get_P1"), "C.P1.get()", "P1");
             VerifyMethodName(compilation, containingType.GetMethod("set_P2"), "C.P2.set(value)", "P2");
             VerifyMethodName(compilation, containingType.GetMethod("set_P3"), "C.P3.init(value)", "P3");
-            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.this[int].get(i)", "this");
-            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.this[int].set(i, value)", "this");
+            VerifyMethodName(compilation, containingType.GetMethod("get_Item"), "C.this[int].get(i)", "this[]");
+            VerifyMethodName(compilation, containingType.GetMethod("set_Item"), "C.this[int].set(i, value)", "this[]");
             VerifyMethodName(compilation, containingType.GetMethod("add_E"), "C.E.add(value)", "E");
             VerifyMethodName(compilation, containingType.GetMethod("remove_E"), "C.E.remove(value)", "E");
             VerifyMethodName(compilation, compilation.GlobalNamespace.GetTypeMember("E").GetMethod("M"), "E.M(x)", "M");

From ac9b4e8f2dc4573c55af8db9ebca0dc7dab6b8df Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Thu, 14 Nov 2024 15:01:23 -0800
Subject: [PATCH 5/5] ParameterOptions.None

---
 .../Source/ExpressionCompiler/CSharpInstructionDecoder.cs    | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
index b4bf74bf56d7f..bd7334fbd67cf 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CSharpInstructionDecoder.cs
@@ -34,8 +34,9 @@ private CSharpInstructionDecoder()
             AddMemberOptions(SymbolDisplayMemberOptions.IncludeParameters).
             WithParameterOptions(SymbolDisplayParameterOptions.IncludeType);
 
-        internal static readonly SymbolDisplayFormat s_indexerCompactNameFormat = CompactNameFormat.
-            WithMemberOptions(SymbolDisplayMemberOptions.IncludeParameters);
+        private static readonly SymbolDisplayFormat s_indexerCompactNameFormat = CompactNameFormat.
+            WithMemberOptions(SymbolDisplayMemberOptions.IncludeParameters).
+            WithParameterOptions(SymbolDisplayParameterOptions.None);
 
         internal override string GetCompactName(MethodSymbol method)
         {