Debugger fixes (#441)

* Update DebuggerTests.cs

* Bump version

* Update ArrayValue.cs

* Update ValueUtils.cs

* Structuring

* Update install_debugadapter.ps1

* Update SessionCache.cs

* Update Binder_Expression.cs

* Update InlayHint.cs

* Update SequencePointInjector.cs

* Update SequencePointInjector.cs

* Update SequencePointInjector.cs

* Update SyntaxHighlighterTests.cs

* Update ValueUtils.cs

scripts/install_debugadapter.ps1

@@ -6,7 +6,7 @@
 
 $ErrorActionPreference = "Stop"
 Push-Location $PSScriptRoot
-dotnet pack ../src/Draco.DebugAdapter --output .
+dotnet pack ../src/Draco.DebugAdapter --configuration Debug --output .
 if ((dotnet tool list --global) -match "Draco.DebugAdapter") {
     dotnet tool uninstall --global Draco.DebugAdapter
 }

src/Draco.Compiler.Tests/Syntax/SyntaxHighlighterTests.cs

@@ -1,5 +1,4 @@
 using System.Collections.Immutable;
-using System.Drawing;
 using Draco.Compiler.Api.Syntax;
 using Draco.Compiler.Tests.Semantics;
 

src/Draco.Compiler/Internal/Binding/Binder_Expression.cs

@@ -628,9 +628,9 @@ private async BindingTask<BoundExpression> BindMemberExpression(MemberExpression
             case Symbol when member.IsError:
                 return new BoundReferenceErrorExpression(syntax, member);
             case FunctionSymbol func:
-                return await this.WrapFunctions(syntax, receiver, [func]);
+                return await this.WrapFunctions(syntax, receiver, [func], constraints, diagnostics);
             case OverloadSymbol overload:
-                return await this.WrapFunctions(syntax, receiver, overload.Functions);
+                return await this.WrapFunctions(syntax, receiver, overload.Functions, constraints, diagnostics);
             case FieldSymbol field:
                 return new BoundFieldExpression(syntax, receiver, field);
             case PropertySymbol prop:
@@ -776,9 +776,9 @@ private async BindingTask<BoundExpression> StaticSymbolToExpression(
             var getter = GetGetterSymbol(syntax, prop, diagnostics);
             return new BoundPropertyGetExpression(syntax, null, getter);
         case FunctionSymbol func:
-            return await this.WrapFunctions(syntax, null, [func]);
+            return await this.WrapFunctions(syntax, null, [func], constraints, diagnostics);
         case OverloadSymbol overload:
-            return await this.WrapFunctions(syntax, null, overload.Functions);
+            return await this.WrapFunctions(syntax, null, overload.Functions, constraints, diagnostics);
         default:
             throw new InvalidOperationException();
         }
@@ -787,7 +787,9 @@ private async BindingTask<BoundExpression> StaticSymbolToExpression(
     private BindingTask<BoundExpression> WrapFunctions(
         SyntaxNode syntax,
         BoundExpression? receiver,
-        ImmutableArray<FunctionSymbol> functions)
+        ImmutableArray<FunctionSymbol> functions,
+        ConstraintSolver constraints,
+        DiagnosticBag diagnostics)
     {
         if (IsMethodOfCallExpression(syntax))
         {
@@ -814,8 +816,13 @@ private BindingTask<BoundExpression> WrapFunctions(
             }
             else
             {
-                // TODO
-                throw new NotImplementedException();
+                // TODO: We should construct some constraints to resolve which one
+                // For now we report an error to not crash tools
+                diagnostics.Add(Diagnostic.Create(
+                    template: TypeCheckingErrors.IllegalExpression,
+                    location: syntax.Location));
+                return BindingTask.FromResult<BoundExpression>(
+                    new BoundReferenceErrorExpression(syntax, WellKnownTypes.ErrorType));
             }
         }
     }

src/Draco.Compiler/Internal/Lowering/SequencePointInjector.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using Draco.Compiler.Api.Syntax;
 using Draco.Compiler.Internal.BoundTree;
+using Draco.Compiler.Internal.Symbols;
 using Draco.Compiler.Internal.Symbols.Synthetized;
 using static Draco.Compiler.Internal.BoundTree.BoundTreeFactory;
 
@@ -12,6 +13,17 @@ namespace Draco.Compiler.Internal.Lowering;
 /// </summary>
 internal sealed class SequencePointInjector : BoundTreeRewriter
 {
+    /// <summary>
+    /// Represents a value that was temporarily stored.
+    /// </summary>
+    /// <param name="Symbol">The synthetized local symbol.</param>
+    /// <param name="Reference">The expression referencing the stored temporary.</param>
+    /// <param name="Assignment">The assignment that stores the temporary.</param>
+    private readonly record struct TemporaryStorage(
+        LocalSymbol Symbol,
+        BoundExpression Reference,
+        BoundStatement Assignment);
+
     public static BoundNode Inject(BoundNode node)
     {
         var rewriter = new SequencePointInjector(node);
@@ -124,9 +136,9 @@ public override BoundNode VisitBlockExpression(BoundBlockExpression node)
             statements:
             [
                 SequencePointStatement(
-                            statement: null,
-                            range: openBrace.Range,
-                            emitNop: true),
+                    statement: null,
+                    range: openBrace.Range,
+                    emitNop: true),
                 LocalDeclaration(blockValue, BlockExpression(
                     locals: node.Locals,
                     statements: statements,
@@ -200,6 +212,74 @@ public override BoundNode VisitWhileExpression(BoundWhileExpression node)
             breakLabel: node.BreakLabel);
     }
 
+    public override BoundNode VisitForExpression(BoundForExpression node)
+    {
+        // For loops are a bit more complex, transformation can be found below
+        //
+        // for (i in SomeSequence) body;
+        //
+        // =>
+        //
+        // val storedSequence = SomeSequence; // first sequence point, pointing at 'SomeSequence'
+        // for (newIterator in storedSequence) {
+        //                     ^^^^^^^^^^^^^^ second sequence point for 'in' keyword
+        //     val i = newIterator; // third sequence point, pointing at 'i'
+        //     body;
+        // }
+
+        var syntax = node.Syntax as ForExpressionSyntax;
+
+        // Wrap the sequence and store it
+        var sequence = (BoundExpression)node.Sequence.Accept(this);
+        var sequenceStorage = StoreTemporary(sequence);
+        var sequenceAssignment = SequencePointStatement(
+            statement: sequenceStorage.Assignment,
+            range: node.Sequence.Syntax?.Range,
+            emitNop: true);
+
+        // Wrap the sequence reference for 'in'
+        var sequenceIn = SequencePointExpression(
+            expression: sequenceStorage.Reference,
+            range: syntax?.InKeyword.Range,
+            emitNop: true);
+
+        // Create a new iterator variable
+        var newIterator = new SynthetizedLocalSymbol(node.Iterator.Type, false);
+
+        // Create the assignment, pointing at the iterator syntax
+        var iteratorAssignment = SequencePointStatement(
+            statement: LocalDeclaration(node.Iterator, LocalExpression(newIterator)),
+            range: syntax?.Iterator.Range,
+            emitNop: true);
+
+        // Wrap the body
+        var then = (BoundExpression)node.Then.Accept(this);
+
+        // Reconstruction
+        return BlockExpression(
+            locals: [sequenceStorage.Symbol],
+            statements:
+            [
+                sequenceAssignment,
+                ExpressionStatement(ForExpression(
+                    iterator: newIterator,
+                    sequence: sequenceIn,
+                    then: BlockExpression(
+                        locals: [node.Iterator],
+                        statements: [
+                            iteratorAssignment,
+                            ExpressionStatement(then),
+                        ],
+                        value: BoundUnitExpression.Default),
+                    continueLabel: node.ContinueLabel,
+                    breakLabel: node.BreakLabel,
+                    getEnumeratorMethod: node.GetEnumeratorMethod,
+                    moveNextMethod: node.MoveNextMethod,
+                    currentProperty: node.CurrentProperty)),
+            ],
+            value: BoundUnitExpression.Default);
+    }
+
     public override BoundNode VisitReturnExpression(BoundReturnExpression node)
     {
         var ancestorBlock = this.GetBlockFunctionBodyAncestor();
@@ -281,9 +361,26 @@ WhileExpressionSyntax @while when ReferenceEquals(syntax, @while.Condition) =>
         };
     }
 
+    // Utility to store an expression to a temporary variable
+    // NOTE: Almost copypaste from local rewriter, but we always store here
+    // this is because here the goal is not eliminating double evaluation,
+    // but to provide a sequence point for a given hidden expression
+    // We also DO NOT call lowering anywhere
+    // If the expression passed in is assumed to be injected, caller should cater for that
+    private static TemporaryStorage StoreTemporary(BoundExpression expr)
+    {
+        var symbol = new SynthetizedLocalSymbol(expr.TypeRequired, false);
+        var symbolRef = LocalExpression(symbol);
+        var assignment = LocalDeclaration(local: symbol, value: expr);
+        return new(symbol, symbolRef, assignment);
+    }
+
     private static bool IsCompoundExpression(BoundExpression expr) => expr switch
     {
-        BoundBlockExpression or BoundWhileExpression or BoundIfExpression => true,
+        BoundBlockExpression
+     or BoundWhileExpression
+     or BoundIfExpression
+     or BoundForExpression => true,
         BoundSequencePointExpression sp => IsCompoundExpression(sp.Expression),
         _ => false,
     };

src/Draco.DebugAdapter/DracoDebugAdapter.cs

@@ -5,6 +5,7 @@
 using Draco.Dap.Adapter;
 using Draco.Dap.Model;
 using Draco.Debugger;
+using Draco.Debugger.Events;
 
 namespace Draco.DebugAdapter;
 

src/Draco.DebugAdapter/Translator.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
+using Draco.Debugger.Breakpoints;
+using Draco.Debugger.RuntimeValues;
 using DapModels = Draco.Dap.Model;
 using DebuggerApi = Draco.Debugger;
 
@@ -44,7 +46,7 @@ public int AllocateId(DapModels.SourceBreakpoint breakpoint)
 
     public IList<DapModels.Variable> GetVariables(int variablesReference)
     {
-        static bool IsCompound(object? value) => value is DebuggerApi.ArrayValue or DebuggerApi.ObjectValue;
+        static bool IsCompound(object? value) => value is ArrayValue or ObjectValue;
 
         if (!this.valueCache.TryGetValue(variablesReference, out var value)) return Array.Empty<DapModels.Variable>();
 
@@ -123,7 +125,7 @@ public DapModels.StackFrame ToDap(DebuggerApi.StackFrame frame)
             : thread.Name,
     };
 
-    public DapModels.Breakpoint ToDap(DebuggerApi.Breakpoint breakpoint, int? id)
+    public DapModels.Breakpoint ToDap(Breakpoint breakpoint, int? id)
     {
         var result = new DapModels.Breakpoint()
         {

src/Draco.Debugger.Tests/DebuggerTests.cs

@@ -28,8 +28,7 @@ func main() {
                     i += 1;
                 }
             }
-            """,
-        this.output);
+            """, this.output);
         var debugger = session.Debugger;
         debugger.Continue();
         await debugger.Terminated;
@@ -39,14 +38,13 @@ func main() {
     public async Task SingleBreakpoint() => await Timeout(async () =>
     {
         var session = await TestDebugSession.DebugAsync("""
-import System.Console;
-func main() {
-    WriteLine("A");
-    WriteLine("B");
-    WriteLine("C");
-}
-""",
-                                        this.output);
+            import System.Console;
+            func main() {
+                WriteLine("A");
+                WriteLine("B");
+                WriteLine("C");
+            }
+            """, this.output);
         var debugger = session.Debugger;
         Assert.True(session.File.TryPlaceBreakpoint(3, out var breakpoint));
         debugger.Continue();
@@ -61,15 +59,14 @@ func main() {
     public async Task MultipleBreakpointBreak() => await Timeout(async () =>
     {
         var session = await TestDebugSession.DebugAsync("""
-                import System.IO;
-                func main() {
-                    var i = 0;
-                    while(i < 10) {
-                        i += 1;
-                    }
+            import System.IO;
+            func main() {
+                var i = 0;
+                while(i < 10) {
+                    i += 1;
                 }
-                """,
-            this.output);
+            }
+            """, this.output);
 
         Assert.True(session.File.TryPlaceBreakpoint(5, out var breakpoint));
 
@@ -92,15 +89,14 @@ func main() {
     public async Task HiddenLocalsDoesNotThrow() => await Timeout(async () =>
     {
         var session = await TestDebugSession.DebugAsync("""
-                import System.Console;
-                func main() {
-                    var i = 1;
-                    WriteLine("\{i.ToString()}a");
-                    WriteLine("\{i.ToString()}b");
-                    WriteLine("\{i.ToString()}c");
-                }
-                """,
-            this.output);
+            import System.Console;
+            func main() {
+                var i = 1;
+                WriteLine("\{i.ToString()}a");
+                WriteLine("\{i.ToString()}b");
+                WriteLine("\{i.ToString()}c");
+            }
+            """, this.output);
 
         var debugger = session.Debugger;
 
@@ -120,12 +116,11 @@ func main() {
     public async Task CanStartProcess() => await Timeout(async () =>
     {
         var session = await TestDebugSession.DebugAsync("""
-                import System.Console;
-                func main() {
-                    WriteLine("Hello, World!");
-                }
-                """,
-                this.output);
+            import System.Console;
+            func main() {
+                WriteLine("Hello, World!");
+            }
+            """, this.output);
 
         var debugger = session.Debugger;
         var output = null as string;

src/Draco.Debugger/Breakpoint.cs → src/Draco.Debugger/Breakpoints/Breakpoint.cs

@@ -1,7 +1,7 @@
 using System.Threading.Tasks;
 using ClrDebug;
 
-namespace Draco.Debugger;
+namespace Draco.Debugger.Breakpoints;
 
 /// <summary>
 /// Represents a breakpoint.

src/Draco.Debugger/EntryPointBreakpoint.cs → src/Draco.Debugger/Breakpoints/EntryPointBreakpoint.cs

@@ -1,6 +1,6 @@
 using ClrDebug;
 
-namespace Draco.Debugger;
+namespace Draco.Debugger.Breakpoints;
 
 internal sealed class EntryPointBreakpoint(
     SessionCache sessionCache,

src/Draco.Debugger/MethodBreakpoint.cs → src/Draco.Debugger/Breakpoints/MethodBreakpoint.cs

@@ -1,6 +1,6 @@
 using ClrDebug;
 
-namespace Draco.Debugger;
+namespace Draco.Debugger.Breakpoints;
 
 // NOTE: Not sealed, entry-point breakpoint reuses this
 internal class MethodBreakpoint : Breakpoint

src/Draco.Debugger/Debugger.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using ClrDebug;
+using Draco.Debugger.Breakpoints;
 using Draco.Debugger.IO;
 
 namespace Draco.Debugger;

src/Draco.Debugger/DebuggerEvents.cs

@@ -1,4 +1,5 @@
 using System;
+using Draco.Debugger.Events;
 
 namespace Draco.Debugger;
 

src/Draco.Debugger/Draco.Debugger.csproj

@@ -5,7 +5,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="ClrDebug" Version="0.3.2" />
+    <PackageReference Include="ClrDebug" Version="0.3.3" />
     <PackageReference Include="Microsoft.Diagnostics.DbgShim" Version="8.0.505301" />
   </ItemGroup>
 

src/Draco.Debugger/OnBreakpointEventArgs.cs → src/Draco.Debugger/Events/OnBreakpointEventArgs.cs

@@ -1,6 +1,7 @@
 using System;
+using Draco.Debugger.Breakpoints;
 
-namespace Draco.Debugger;
+namespace Draco.Debugger.Events;
 
 /// <summary>
 /// The event arguments for the event when a breakpoint is hit.