[LogDebugger] Do not proceed to first breakpoint when set

Setting the breakpoints had a unexpected side effect: when line == 1 it would
proceed to the first breakpoint. This seems kinda unexpected, so I removed the
behavior.

Author: ttiimm

editors/code/src/debugAdapter.ts

@@ -135,7 +135,7 @@ export class DebugSession extends LoggingDebugSession {
 
         const source = args.source.path as string;
         const bps = args.breakpoints || [];
-        const breakpoints = this._logDebugger.setBreakPoint(source, bps);
+        const breakpoints = this._logDebugger.setBreakpoints(source, bps);
 
         response.body = {
             breakpoints: breakpoints
@@ -210,15 +210,15 @@ export class DebugSession extends LoggingDebugSession {
     protected continueRequest(response: DebugProtocol.ContinueResponse, args: DebugProtocol.ContinueArguments): void {
         console.log(`continueRequest ${JSON.stringify(args)}`);
 
-        this._logDebugger.gotoNextBreakpoint();
+        this._logDebugger.gotoBreakpoint();
         this.sendEvent(new StoppedEvent('breakpoint', DebugSession._threadID));
         this.sendResponse(response);
     }
 
     protected reverseContinueRequest(response: DebugProtocol.ReverseContinueResponse, args: DebugProtocol.ReverseContinueArguments): void {
         console.log(`reverseContinueRequest ${JSON.stringify(args)}`);
 
-        this._logDebugger.gotoNextBreakpoint(true);
+        this._logDebugger.gotoBreakpoint(true);
         this.sendEvent(new StoppedEvent('breakpoint', DebugSession._threadID));
         this.sendResponse(response);
     }

editors/code/src/logDebugger.ts

@@ -22,14 +22,11 @@ export class LogDebugger {
         this._logLines = logLines;
     }
 
-    setBreakPoint(source: string, breakpoints: DebugProtocol.SourceBreakpoint[]): DebugProtocol.Breakpoint[] {
+    setBreakpoints(source: string, breakpoints: DebugProtocol.SourceBreakpoint[]): DebugProtocol.Breakpoint[] {
         const bps = new Array<DebugProtocol.Breakpoint>();
         const sourcePath = path.resolve(source);
         this._breakPoints.set(sourcePath, bps);
         breakpoints.forEach((breakpoint) => {
-            if (this._line === 1) {
-                this._line = breakpoint.line;
-            }
             const verified = breakpoint.line > 0 && breakpoint.line < this._logLines;
             bps.push({ line: breakpoint.line, verified: verified });
         });
@@ -53,7 +50,7 @@ export class LogDebugger {
         this._line = Math.max(1, this._line - 1);
     }
 
-    gotoNextBreakpoint(reverse = false): void {
+    gotoBreakpoint(reverse = false): void {
         this._line = this.findNextLineToStop(reverse);
     }
 

editors/code/src/test/suite/logDebugger.test.ts

@@ -52,49 +52,47 @@ suite('LogDebugger Test Suite', () => {
 
         test('hasBreakpoints is true after breakpoints set', () => {
             logDebugger.setToLog(logPath, 100);
-            logDebugger.setBreakPoint(logPath, [{ line: 10 }]);
+            logDebugger.setBreakpoints(logPath, [{ line: 10 }]);
             assert.ok(logDebugger.hasBreakpoints());
         });
 
         test('hasBreakpoints is false after empty breakpoints set', () => {
             logDebugger.setToLog(logPath, 100);
-            logDebugger.setBreakPoint(logPath, []);
+            logDebugger.setBreakpoints(logPath, []);
             assert.strictEqual(logDebugger.hasBreakpoints(), false);
         });
 
         test('gotoNextBreakpoint advances to next breakpoint', () => {
             logDebugger.setToLog(logPath, 100);
-            // setBreakPoint moves _line to the first breakpoint (10) when starting at line 1
-            logDebugger.setBreakPoint(logPath, [{ line: 10 }, { line: 20 }, { line: 30 }]);
+            logDebugger.setBreakpoints(logPath, [{ line: 10 }, { line: 20 }, { line: 30 }]);
+            assert.strictEqual(logDebugger.linenum(), 1);
+            logDebugger.gotoBreakpoint();
             assert.strictEqual(logDebugger.linenum(), 10);
-            logDebugger.gotoNextBreakpoint();
+            logDebugger.gotoBreakpoint();
             assert.strictEqual(logDebugger.linenum(), 20);
-            logDebugger.gotoNextBreakpoint();
-            assert.strictEqual(logDebugger.linenum(), 30);
         });
 
         test('gotoNextBreakpoint reverse retreats to previous breakpoint', () => {
             logDebugger.setToLog(logPath, 100);
-            // setBreakPoint moves _line to 10; navigate forward to 30, then reverse to 20
-            logDebugger.setBreakPoint(logPath, [{ line: 10 }, { line: 20 }, { line: 30 }]);
-            logDebugger.gotoNextBreakpoint();   // 10 → 20
-            logDebugger.gotoNextBreakpoint();   // 20 → 30
-            logDebugger.gotoNextBreakpoint(true); // 30 → 20
-            assert.strictEqual(logDebugger.linenum(), 20);
+            logDebugger.setBreakpoints(logPath, [{ line: 10 }, { line: 20 }, { line: 30 }]);
+            logDebugger.gotoBreakpoint();   // 1 → 10
+            logDebugger.gotoBreakpoint();   // 10 → 20
+            logDebugger.gotoBreakpoint(true); // 20 → 10
+            assert.strictEqual(logDebugger.linenum(), 10);
         });
 
         test('gotoNextBreakpoint past last clamps to logLines', () => {
             logDebugger.setToLog(logPath, 100);
-            logDebugger.setBreakPoint(logPath, [{ line: 10 }]);
-            logDebugger.gotoNextBreakpoint();
-            logDebugger.gotoNextBreakpoint();
+            logDebugger.setBreakpoints(logPath, [{ line: 10 }]);
+            logDebugger.gotoBreakpoint();
+            logDebugger.gotoBreakpoint();
             assert.strictEqual(logDebugger.linenum(), 100);
         });
 
         test('gotoNextBreakpoint before first in reverse clamps to line 1', () => {
             logDebugger.setToLog(logPath, 100);
-            logDebugger.setBreakPoint(logPath, [{ line: 10 }]);
-            logDebugger.gotoNextBreakpoint(true);
+            logDebugger.setBreakpoints(logPath, [{ line: 10 }]);
+            logDebugger.gotoBreakpoint(true);
             assert.strictEqual(logDebugger.linenum(), 1);
         });
     });