Fix setbreakPointsRequest (#33)

In case of invalid breakpoint (not allowed every line in the engine)
a message will be rendered into the breakpoint and the breakpoint itself
will be unverified.
In case of reconnection the previously added breakpoints will be checked
and will be activated or unverified by the engine.

IoT.js-Debug-DCO-1.0-Signed-off-by: Imre Kiss [email protected]

Author: knightburton

src/IotjsDebugger.ts

@@ -18,18 +18,19 @@
 
 import {
   DebugSession, InitializedEvent, OutputEvent, Thread, Source,
-  StoppedEvent, ContinuedEvent, StackFrame, TerminatedEvent, Breakpoint as AdapterBreakpoint, Event, ErrorDestination
+  StoppedEvent, ContinuedEvent, StackFrame, TerminatedEvent, Event, ErrorDestination
 } from 'vscode-debugadapter';
 import { DebugProtocol } from 'vscode-debugprotocol';
 import * as Fs from 'fs';
 import * as Path from 'path';
-import { IAttachRequestArguments, SourceSendingOptions } from './IotjsDebuggerInterfaces';
+import { IAttachRequestArguments, SourceSendingOptions, TemporaryBreakpoint } from './IotjsDebuggerInterfaces';
 import { JerryDebuggerClient, JerryDebuggerOptions } from './JerryDebuggerClient';
 import {
   JerryDebugProtocolDelegate, JerryDebugProtocolHandler, JerryMessageScriptParsed, JerryEvalResult,
   JerryMessageExceptionHit
 } from './JerryProtocolHandler';
 import { EVAL_RESULT_SUBTYPE, CLIENT as CLIENT_PACKAGE } from './JerryProtocolConstants';
+import { Breakpoint } from './JerryBreakpoints';
 
 enum SOURCE_SENDING_STATES {
   NOP = 0,
@@ -76,8 +77,6 @@ class IotjsDebugSession extends DebugSession {
   ): void {
     this.log('initializeRequest');
 
-    this.sendEvent(new InitializedEvent());
-
     // This debug adapter implements the configurationDoneRequest.
     response.body.supportsConfigurationDoneRequest = true;
     response.body.supportsFunctionBreakpoints = false;
@@ -189,9 +188,10 @@ class IotjsDebugSession extends DebugSession {
       .catch(error => {
         this.log(error);
         this.sendErrorResponse(response, 0, error.message);
+      })
+      .then(() => {
+        this.sendEvent(new InitializedEvent());
       });
-
-    this.sendEvent(new InitializedEvent());
   }
 
   protected launchRequest(response: DebugProtocol.LaunchResponse, args: DebugProtocol.LaunchRequestArguments): void {
@@ -272,45 +272,51 @@ class IotjsDebugSession extends DebugSession {
   ): Promise<void> {
     this.log('setBreakPointsRequest');
 
-    const filename = args.source.name;
-    const clientLines = args.lines || [];
+    const filename: string = args.source.name;
+    const vscodeBreakpoints: DebugProtocol.Breakpoint[] = args.breakpoints!.map(b => ({verified: false, line: b.line}));
 
     try {
-      const scriptId = this._protocolhandler.getScriptIdByName(filename);
-      const activeBp = this._protocolhandler.getActiveBreakpointsByScriptId(scriptId);
-      const activeBpLines = activeBp.map(b => b.line);
-
-      const newBp = clientLines.filter(b => activeBpLines.indexOf(b) === -1);
-      const removeBp = activeBpLines.filter(b => clientLines.indexOf(b) === -1);
-      const persistingBp = clientLines.filter(b => newBp.indexOf(b) === -1);
-
-      let newBreakpoints: DebugProtocol.Breakpoint[] = [];
-      await Promise.all(newBp.map(async b => {
-        const breakpoint = this._protocolhandler.findBreakpoint(scriptId, b);
-        return await this._protocolhandler.updateBreakpoint(breakpoint, true)
-          .then(() => <DebugProtocol.Breakpoint> new AdapterBreakpoint(true, b));
-      }))
-      .then(breakpoints => {
-        newBreakpoints = breakpoints;
-      });
+      const scriptId: number = this._protocolhandler.getScriptIdByName(filename);
+      const activeBps: Breakpoint[] = this._protocolhandler.getActiveBreakpointsByScriptId(scriptId);
+
+      // Get the new breakpoints.
+      const activeBpsLines: number[] = activeBps.map(b => b.line);
+      const newBps: DebugProtocol.Breakpoint[] = vscodeBreakpoints.filter(b => activeBpsLines.indexOf(b.line) === -1);
+
+      const newBreakpoints: TemporaryBreakpoint[] = await Promise.all(newBps.map(async (breakpoint, index) => {
+        try {
+          const jerryBreakpoint: Breakpoint = this._protocolhandler.findBreakpoint(scriptId, breakpoint.line);
+          await this._protocolhandler.updateBreakpoint(jerryBreakpoint, true);
+          return <TemporaryBreakpoint>{verified: true, line: breakpoint.line};
+        } catch (error) {
+          this.log(error);
+          return <TemporaryBreakpoint>{verified: false, line: breakpoint.line, message: (<Error>error).message};
+        }
+      }));
 
-      removeBp.forEach(async b => {
-        const breakpoint = this._protocolhandler.findBreakpoint(scriptId, b);
-        await this._protocolhandler.updateBreakpoint(breakpoint, false);
-      });
+      // Get the persists breakpoints.
+      const newBreakpointsLines: number[] = newBreakpoints.map(b => b.line);
+      const persistingBreakpoints: TemporaryBreakpoint[] = vscodeBreakpoints
+                                    .filter(b => newBreakpointsLines.indexOf(b.line) === -1)
+                                    .map(b => ({verified: true, line: b.line}));
 
-      const persistingBreakpoints = persistingBp.map(b => {
-        return <DebugProtocol.Breakpoint> new AdapterBreakpoint(true, b);
-      });
+      // Get the removalbe breakpoints.
+      const vscodeBreakpointsLines: number[] = vscodeBreakpoints.map(b => b.line);
+      const removeBps: Breakpoint[] = activeBps.filter(b => vscodeBreakpointsLines.indexOf(b.line) === -1);
 
-      response.body = {
-        breakpoints: [...persistingBreakpoints, ...newBreakpoints]
-      };
+      removeBps.forEach(async b => {
+        const jerryBreakpoint = this._protocolhandler.findBreakpoint(scriptId, b.line);
+        await this._protocolhandler.updateBreakpoint(jerryBreakpoint, false);
+      });
 
-      this.sendResponse(response);
+      response.body = { breakpoints: [...persistingBreakpoints, ...newBreakpoints] };
     } catch (error) {
       this.log(error.message);
+      this.sendErrorResponse(response, error.message);
+      return;
     }
+
+    this.sendResponse(response);
   }
 
   protected evaluateRequest(response: DebugProtocol.EvaluateResponse, args: DebugProtocol.EvaluateArguments): void {

src/IotjsDebuggerInterfaces.d.ts

@@ -39,3 +39,12 @@ export interface SourceSendingOptions {
   // Actual state of source sending.
   state: number;
 }
+
+export interface TemporaryBreakpoint {
+  // The breakpoint is verified or not by the engine.
+  verified: boolean;
+  // Line position in the file.
+  line: number;
+  // Extra error or info message.
+  message?: string;
+}

src/JerryProtocolHandler.ts

@@ -674,13 +674,13 @@ export class JerryDebugProtocolHandler {
 
     if (enable) {
       if (breakpoint.activeIndex !== -1) {
-        return Promise.reject('breakpoint already enabled');
+        return Promise.reject(new Error('breakpoint already enabled'));
       }
       breakpointId = breakpoint.activeIndex = this.nextBreakpointIndex++;
       this.activeBreakpoints[breakpointId] = breakpoint;
     } else {
       if (breakpoint.activeIndex === -1) {
-        return Promise.reject('breakpoint already disabled');
+        return Promise.reject(new Error('breakpoint already disabled'));
       }
       breakpointId = breakpoint.activeIndex;
       delete this.activeBreakpoints[breakpointId];

src/test/JerryProtocolHandler.test.ts

@@ -466,7 +466,7 @@ suite('JerryProtocolHandler', () => {
             const handler = new JerryDebugProtocolHandler({});
             await handler.updateBreakpoint(bp, true)
                 .catch(error => {
-                    assert.strictEqual(error, 'breakpoint already enabled');
+                    assert.strictEqual((<Error>error).message, 'breakpoint already enabled');
                 });
         });
 
@@ -476,7 +476,7 @@ suite('JerryProtocolHandler', () => {
             const handler = new JerryDebugProtocolHandler({});
             await handler.updateBreakpoint(bp, false)
                 .catch(error => {
-                    assert.strictEqual(error, 'breakpoint already disabled');
+                    assert.strictEqual((<Error>error).message, 'breakpoint already disabled');
                 });
         });