[wasm][debugger] Improvement of memory consumption while Evaluating Expressions

src/mono/wasm/debugger/BrowserDebugProxy/BrowserDebugProxy.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.7.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.7" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.7.0" />

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

@@ -12,17 +12,21 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Scripting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Scripting;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.Text.RegularExpressions;
 
 namespace Microsoft.WebAssembly.Diagnostics
 {
     internal static class EvaluateExpression
     {
         private class FindVariableNMethodCall : CSharpSyntaxWalker
         {
+            private static Regex regexForReplaceVarName = new Regex(@"[^A-Za-z0-9_]", RegexOptions.Singleline);
             public List<IdentifierNameSyntax> identifiers = new List<IdentifierNameSyntax>();
             public List<InvocationExpressionSyntax> methodCall = new List<InvocationExpressionSyntax>();
             public List<MemberAccessExpressionSyntax> memberAccesses = new List<MemberAccessExpressionSyntax>();
@@ -32,6 +36,7 @@ private class FindVariableNMethodCall : CSharpSyntaxWalker
             private int visitCount;
             public bool hasMethodCalls;
             public bool hasElementAccesses;
+            internal StringBuilder variableDefinition = new StringBuilder();
 
             public void VisitInternal(SyntaxNode node)
             {
@@ -97,7 +102,7 @@ public SyntaxTree ReplaceVars(SyntaxTree syntaxTree, IEnumerable<JObject> ma_val
                     {
                         // Generate a random suffix
                         string suffix = Guid.NewGuid().ToString().Substring(0, 5);
-                        string prefix = ma_str.Trim().Replace(".", "_");
+                        string prefix = regexForReplaceVarName.Replace(ma_str, "_");
                         id_name = $"{prefix}_{suffix}";
 
                         memberAccessToParamName[ma_str] = id_name;
@@ -114,7 +119,7 @@ public SyntaxTree ReplaceVars(SyntaxTree syntaxTree, IEnumerable<JObject> ma_val
                     {
                         // Generate a random suffix
                         string suffix = Guid.NewGuid().ToString().Substring(0, 5);
-                        string prefix = iesStr.Trim().Replace(".", "_").Replace("(", "_").Replace(")", "_");
+                        string prefix = regexForReplaceVarName.Replace(iesStr, "_");
                         id_name = $"{prefix}_{suffix}";
                         methodCallToParamName[iesStr] = id_name;
                     }
@@ -151,15 +156,15 @@ public SyntaxTree ReplaceVars(SyntaxTree syntaxTree, IEnumerable<JObject> ma_val
                             throw new Exception($"BUG: Expected to find an id name for the member access string: {node_str}");
                         }
                         memberAccessValues[id_name] = value;
-                        root = UpdateWithNewMethodParam(root, id_name, value);
+                        root = CreateNAssingVariableForExpression(id_name, value);
                     }
                 }
 
                 if (id_values != null)
                 {
                     foreach ((IdentifierNameSyntax idns, JObject value) in identifiers.Zip(id_values))
                     {
-                        root = UpdateWithNewMethodParam(root, idns.Identifier.Text, value);
+                        root = CreateNAssingVariableForExpression(idns.Identifier.Text, value);
                     }
                 }
 
@@ -172,7 +177,7 @@ public SyntaxTree ReplaceVars(SyntaxTree syntaxTree, IEnumerable<JObject> ma_val
                         {
                             throw new Exception($"BUG: Expected to find an id name for the member access string: {node_str}");
                         }
-                        root = UpdateWithNewMethodParam(root, id_name, value);
+                        root = CreateNAssingVariableForExpression(id_name, value);
                     }
                 }
 
@@ -185,34 +190,22 @@ public SyntaxTree ReplaceVars(SyntaxTree syntaxTree, IEnumerable<JObject> ma_val
                         {
                             throw new Exception($"BUG: Expected to find an id name for the element access string: {node_str}");
                         }
-                        root = UpdateWithNewMethodParam(root, id_name, value);
+                        root = CreateNAssingVariableForExpression(id_name, value);
                     }
                 }
 
                 return syntaxTree.WithRootAndOptions(root, syntaxTree.Options);
 
-                CompilationUnitSyntax UpdateWithNewMethodParam(CompilationUnitSyntax root, string id_name, JObject value)
+                CompilationUnitSyntax CreateNAssingVariableForExpression(string id_name, JObject value)
                 {
-                    var classDeclaration = root.Members.ElementAt(0) as ClassDeclarationSyntax;
-                    var method = classDeclaration.Members.ElementAt(0) as MethodDeclarationSyntax;
-
                     if (paramsSet.Contains(id_name))
                     {
                         // repeated member access expression
                         // eg. this.a + this.a
                         return root;
                     }
-
-                    argValues.Add(ConvertJSToCSharpType(value));
-
-                    MethodDeclarationSyntax updatedMethod = method.AddParameterListParameters(
-                        SyntaxFactory.Parameter(
-                            SyntaxFactory.Identifier(id_name))
-                            .WithType(SyntaxFactory.ParseTypeName(GetTypeFullName(value))));
-
                     paramsSet.Add(id_name);
-                    root = root.ReplaceNode(method, updatedMethod);
-
+                    variableDefinition.Append($"{GetTypeFullName(value)} {id_name} = {ConvertJSToCSharpType(value)};\n");
                     return root;
                 }
             }
@@ -222,59 +215,60 @@ private object ConvertJSToCSharpType(JToken variable)
                 JToken value = variable["value"];
                 string type = variable["type"].Value<string>();
                 string subType = variable["subtype"]?.Value<string>();
-
+                string objectId = variable["objectId"]?.Value<string>();
                 switch (type)
                 {
                     case "string":
-                        return value?.Value<string>();
+                    {
+                        var str = value?.Value<string>();
+                        str = str.Replace("\"", "\\\"");
+                        return $"\"{str}\"";
+                    }
                     case "number":
                         return value?.Value<double>();
                     case "boolean":
-                        return value?.Value<bool>();
+                        return value?.Value<string>().ToLower();
                     case "object":
-                        return variable;
+                    {
+                        return "Newtonsoft.Json.Linq.JObject.FromObject(new {"
+                            + $"type = \"{type}\""
+                            + $", description = \"{variable["description"].Value<string>()}\""
+                            + $", className = \"{variable["className"].Value<string>()}\""
+                            + (subType != null ? $", subtype = \"{subType}\"" : "")
+                            + (objectId != null ? $", objectId = \"{objectId}\"" : "")
+                            + "})";
+                    }
                     case "void":
-                        return null;
+                        return "Newtonsoft.Json.Linq.JObject.FromObject(new {"
+                                + $"type = \"object\","
+                                + $"description = \"object\","
+                                + $"className = \"object\","
+                                + $"subtype = \"null\""
+                                + "})";
                 }
                 throw new Exception($"Evaluate of this datatype {type} not implemented yet");//, "Unsupported");
             }
 
             private string GetTypeFullName(JToken variable)
             {
                 string type = variable["type"].ToString();
-                string subType = variable["subtype"]?.Value<string>();
                 object value = ConvertJSToCSharpType(variable);
 
                 switch (type)
                 {
                     case "object":
-                        {
-                            if (subType == "null")
-                                return variable["className"].Value<string>();
-                            else
-                                return "object";
-                        }
+                        return "object";
                     case "void":
                         return "object";
+                    case "boolean":
+                        return "System.Boolean";
                     default:
                         return value.GetType().FullName;
                 }
                 throw new ReturnAsErrorException($"GetTypefullName: Evaluate of this datatype {type} not implemented yet", "Unsupported");
             }
         }
 
-        private static SyntaxNode GetExpressionFromSyntaxTree(SyntaxTree syntaxTree)
-        {
-            CompilationUnitSyntax root = syntaxTree.GetCompilationUnitRoot();
-            ClassDeclarationSyntax classDeclaration = root.Members.ElementAt(0) as ClassDeclarationSyntax;
-            MethodDeclarationSyntax methodDeclaration = classDeclaration.Members.ElementAt(0) as MethodDeclarationSyntax;
-            BlockSyntax blockValue = methodDeclaration.Body;
-            ReturnStatementSyntax returnValue = blockValue.Statements.ElementAt(0) as ReturnStatementSyntax;
-            ParenthesizedExpressionSyntax expressionParenthesized = returnValue.Expression as ParenthesizedExpressionSyntax;
-
-            return expressionParenthesized?.Expression;
-        }
-
         private static async Task<IList<JObject>> ResolveMemberAccessExpressions(IEnumerable<MemberAccessExpressionSyntax> member_accesses,
                                 MemberReferenceResolver resolver, CancellationToken token)
         {
@@ -335,32 +329,20 @@ private static async Task<IList<JObject>> ResolveElementAccess(IEnumerable<Eleme
             return values;
         }
 
-        [UnconditionalSuppressMessage("SingleFile", "IL3000:Avoid accessing Assembly file path when publishing as a single file",
-            Justification = "Suppressing the warning until gets fixed, see https://github.com/dotnet/runtime/issues/51202")]
         internal static async Task<JObject> CompileAndRunTheExpression(string expression, MemberReferenceResolver resolver, CancellationToken token)
         {
             expression = expression.Trim();
             if (!expression.StartsWith('('))
             {
                 expression = "(" + expression + ")";
             }
-            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@"
-                using System;
-                public class CompileAndRunTheExpression
-                {
-                    public static object Evaluate()
-                    {
-                        return " + expression + @";
-                    }
-                }", cancellationToken: token);
+            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(expression + @";", cancellationToken: token);
 
-            SyntaxNode expressionTree = GetExpressionFromSyntaxTree(syntaxTree);
+            SyntaxNode expressionTree = syntaxTree.GetCompilationUnitRoot(token);
             if (expressionTree == null)
                 throw new Exception($"BUG: Unable to evaluate {expression}, could not get expression from the syntax tree");
-
             FindVariableNMethodCall findVarNMethodCall = new FindVariableNMethodCall();
             findVarNMethodCall.VisitInternal(expressionTree);
-
             // this fails with `"a)"`
             // because the code becomes: return (a));
             // and the returned expression from GetExpressionFromSyntaxTree is `a`!
@@ -388,7 +370,7 @@ public static object Evaluate()
 
             if (findVarNMethodCall.hasMethodCalls)
             {
-                expressionTree = GetExpressionFromSyntaxTree(syntaxTree);
+                expressionTree = syntaxTree.GetCompilationUnitRoot(token);
 
                 findVarNMethodCall.VisitInternal(expressionTree);
 
@@ -400,7 +382,7 @@ public static object Evaluate()
             // eg. "elements[0]"
             if (findVarNMethodCall.hasElementAccesses)
             {
-                expressionTree = GetExpressionFromSyntaxTree(syntaxTree);
+                expressionTree = syntaxTree.GetCompilationUnitRoot(token);
 
                 findVarNMethodCall.VisitInternal(expressionTree);
 
@@ -409,48 +391,25 @@ public static object Evaluate()
                 syntaxTree = findVarNMethodCall.ReplaceVars(syntaxTree, null, null, null, elementAccessValues);
             }
 
-            expressionTree = GetExpressionFromSyntaxTree(syntaxTree);
+            expressionTree = syntaxTree.GetCompilationUnitRoot(token);
             if (expressionTree == null)
                 throw new Exception($"BUG: Unable to evaluate {expression}, could not get expression from the syntax tree");
 
-            MetadataReference[] references = new MetadataReference[]
-            {
-                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
-                MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location)
-            };
-
-            CSharpCompilation compilation = CSharpCompilation.Create(
-                "compileAndRunTheExpression",
-                syntaxTrees: new[] { syntaxTree },
-                references: references,
-                options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-
-            SemanticModel semanticModel = compilation.GetSemanticModel(syntaxTree);
-            CodeAnalysis.TypeInfo TypeInfo = semanticModel.GetTypeInfo(expressionTree, cancellationToken: token);
-
-            using (var ms = new MemoryStream())
+            try {
+                var result = await CSharpScript.EvaluateAsync(
+                    findVarNMethodCall.variableDefinition + "return " + syntaxTree.ToString(),
+                    ScriptOptions.Default.WithReferences(
+                        typeof(object).Assembly,
+                        typeof(Enumerable).Assembly,
+                        typeof(JObject).Assembly
+                        ),
+                    cancellationToken: token);
+                return JObject.FromObject(ConvertCSharpToJSType(result, result.GetType()));
+            }
+            catch (Exception)
             {
-                EmitResult result = compilation.Emit(ms, cancellationToken: token);
-                if (!result.Success)
-                {
-                    var sb = new StringBuilder();
-                    foreach (Diagnostic d in result.Diagnostics)
-                        sb.Append(d.ToString());
-
-                    throw new ReturnAsErrorException(sb.ToString(), "CompilationError");
-                }
-
-                ms.Seek(0, SeekOrigin.Begin);
-                Assembly assembly = Assembly.Load(ms.ToArray());
-                Type type = assembly.GetType("CompileAndRunTheExpression");
-
-                object ret = type.InvokeMember("Evaluate",
-                    BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public,
-                    null,
-                    null,
-                    findVarNMethodCall.argValues.ToArray());
-
-                return JObject.FromObject(ConvertCSharpToJSType(ret, TypeInfo.Type));
+                Console.WriteLine(findVarNMethodCall.variableDefinition + "return " + syntaxTree.ToString());
+                throw new ReturnAsErrorException($"Cannot evaluate '{expression}'.", "CompilationError");
             }
         }
 
@@ -462,7 +421,7 @@ public static object Evaluate()
             typeof(float), typeof(double)
         };
 
-        private static object ConvertCSharpToJSType(object v, ITypeSymbol type)
+        private static object ConvertCSharpToJSType(object v, Type type)
         {
             if (v == null)
                 return new { type = "object", subtype = "null", className = type.ToString(), description = type.ToString() };

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

@@ -461,7 +461,7 @@ public async Task NegativeTestsInStaticMethod() => await CheckInspectLocalsAtBre
 
                await EvaluateOnCallFrameFail(id,
                    ("me.foo", "ReferenceError"),
-                   ("this", "ReferenceError"),
+                   ("this", "CompilationError"),
                    ("this.NullIfAIsNotZero.foo", "ReferenceError"));
            });
 
@@ -542,6 +542,7 @@ await EvaluateOnCallFrameAndCheck(id,
                     ("this.CallMethodWithParmBool(true)", TString("TRUE")),
                     ("this.CallMethodWithParmBool(false)", TString("FALSE")),
                     ("this.CallMethodWithParmString(\"concat\")", TString("str_const_concat")),
+                    ("this.CallMethodWithParmString(\"\\\"\\\"\")", TString("str_const_\"\"")),
                     ("this.CallMethodWithParm(10) + this.a", TNumber(12)),
                     ("this.CallMethodWithObj(null)", TNumber(-1)),
                     ("this.CallMethodWithChar('a')", TString("str_const_a")));