[wasm][debugger] Support indexing by value type schema

src/mono/wasm/debugger/BrowserDebugProxy/EvaluateExpression.cs

@@ -277,8 +277,20 @@ public static string ConvertJSToCSharpLocalVariableAssignment(string idName, JTo
                         switch (objectId?.Scheme)
                         {
                             case "valuetype" when variable["isEnum"]?.Value<bool>() == true:
-                                typeRet = variable["className"]?.Value<string>();
-                                valueRet = $"({typeRet}) {value["value"].Value<double>()}";
+                                 // using Enum Type from variable["className"] requires adding references to assemblies
+                                 // with this type definition - it's easier to use the underlying numeric type
+                                typeRet = "double";
+                                // when indexing with enums, enum object is packed in another enum
+                                // which is not the case in other scenarios
+                                try
+                                {
+                                    valueRet = $"({typeRet}) {value["value"].Value<double>()}";
+                                }
+                                catch (InvalidCastException)
+                                {
+                                    // value["value"] is JObject with another "value" field
+                                    valueRet = $"({typeRet}) {value["value"]["value"].Value<double>()}";
+                                }
                                 break;
                             case "object":
                             default:
@@ -472,6 +484,15 @@ internal static async Task<List<string>> GetVariableDefinitions(MemberReferenceR
             {
                 if (!invokeToStringInObject || definition.Obj?["type"]?.Value<string>() != "object")
                 {
+                    if (definition.Obj?["type"]?.Value<string>() == "object" &&
+                        definition.Obj?["isValueType"]?.Value<bool>() == true &&
+                        definition.Obj?["isEnum"]?.Value<bool>() == true)
+                    {
+                        JObject value = definition.Obj?["value"]?.Value<JObject>();
+                        string strigifiedDefinition = ConvertJSToCSharpLocalVariableAssignment(definition.IdName, value);
+                        variableDefStrings.Add(strigifiedDefinition);
+                        continue;
+                    }
                     variableDefStrings.Add(definition.Definition);
                     continue;
                 }

src/mono/wasm/debugger/DebuggerTestSuite/EvaluateOnCallFrameTests.cs

@@ -585,7 +585,7 @@ public async Task EvaluateIndexingNegative() => await CheckInspectLocalsAtBreakp
                 Assert.Equal("Unable to evaluate element access 'f.idx0[2]': Cannot apply indexing with [] to a primitive object of type 'number'", res.Error["result"]?["description"]?.Value<string>());
                 var exceptionDetailsStack = res.Error["exceptionDetails"]?["stackTrace"]?["callFrames"]?[0];
                 Assert.Equal("DebuggerTests.EvaluateLocalsWithIndexingTests.EvaluateLocals", exceptionDetailsStack?["functionName"]?.Value<string>());
-                Assert.Equal(556, exceptionDetailsStack?["lineNumber"]?.Value<int>());
+                Assert.Equal(569, exceptionDetailsStack?["lineNumber"]?.Value<int>());
                 Assert.Equal(12, exceptionDetailsStack?["columnNumber"]?.Value<int>());
                 (_, res) = await EvaluateOnCallFrame(id, "f[1]", expect_ok: false );
                 Assert.Equal( "Unable to evaluate element access 'f[1]': Cannot apply indexing with [] to an object of type 'DebuggerTests.EvaluateLocalsWithIndexingTests.TestEvaluate'", res.Error["result"]?["description"]?.Value<string>());
@@ -650,7 +650,7 @@ await EvaluateOnCallFrameAndCheck(id,
 
         [Fact]
         public async Task EvaluateObjectByNonIntLocals() => await CheckInspectLocalsAtBreakpointSite(
-            "DebuggerTests.EvaluateLocalsWithIndexingTests", "EvaluateLocals", 12, "DebuggerTests.EvaluateLocalsWithIndexingTests.EvaluateLocals",
+            "DebuggerTests.EvaluateLocalsWithIndexingTests", "EvaluateLocals", 14, "DebuggerTests.EvaluateLocalsWithIndexingTests.EvaluateLocals",
             "window.setTimeout(function() { invoke_static_method ('[debugger-test] DebuggerTests.EvaluateLocalsWithIndexingTests:EvaluateLocals'); })",
             wait_for_event_fn: async (pause_location) =>
             {
@@ -662,7 +662,8 @@ await EvaluateOnCallFrameAndCheck(id,
                     ("f[shortString]", TBool(false)),
                     ("f[aFloat]", TNumber(1)),
                     ("f[aDouble]", TNumber(2)),
-                    ("f[aDecimal]", TNumber(3)) // object
+                    ("f[enumIdx]", TString("Index is High")),
+                    ("f[structIdx]", TBool(true))
                 );
             });
 
@@ -722,7 +723,7 @@ public async Task EvaluateIndexingByExpressionNegative() => await CheckInspectLo
                 Assert.Equal("Unable to evaluate element access 'f.numList[\"a\" + 1]': Cannot index with an object of type 'string'", res.Error["result"]?["description"]?.Value<string>());
                 var exceptionDetailsStack = res.Error["exceptionDetails"]?["stackTrace"]?["callFrames"]?[0];
                 Assert.Equal("DebuggerTests.EvaluateLocalsWithIndexingTests.EvaluateLocals", exceptionDetailsStack?["functionName"]?.Value<string>());
-                Assert.Equal(556, exceptionDetailsStack?["lineNumber"]?.Value<int>());
+                Assert.Equal(569, exceptionDetailsStack?["lineNumber"]?.Value<int>());
                 Assert.Equal(12, exceptionDetailsStack?["columnNumber"]?.Value<int>());
             });
 

src/mono/wasm/debugger/tests/debugger-test/debugger-evaluate-test.cs

@@ -506,6 +506,17 @@ public async void run()
 
     public class EvaluateLocalsWithIndexingTests
     {
+        public enum EnumIndexer
+        {
+            High,
+            Low
+        }
+
+        public struct StructIndexer
+        {
+            public bool HasIndex;
+        }
+
         public class TestEvaluate
         {
             public List<int> numList;
@@ -529,6 +540,8 @@ public class TestEvaluate
             public int this[double key] => (int)key;
             public int this[float key] => (int)key;
             public int this[decimal key] => (int)key;
+            public string this[EnumIndexer indexer] => $"Index is {indexer}";
+            public bool this[StructIndexer indexer] => indexer.HasIndex;
 
             public void run()
             {
@@ -561,6 +574,8 @@ public static void EvaluateLocals()
             float aFloat = 1.23f;
             double aDouble = 2.34;
             decimal aDecimal = 3.34m;
+            EnumIndexer enumIdx = EnumIndexer.High;
+            StructIndexer structIdx = new() { HasIndex = true };
         }
     }