Add function breakpoint request

Implement the setFunctionBreakPointRequest in the DebugSession.
This will allow the users to set a breakpoint to a function (in iotjs and jerry
this means the first statement in the function core).

IoT.js-VSCode-DCO-1.0-Signed-off-by: Imre Kiss kissi.szeged@partner.samsung.com

Author: knightburton

src/IotjsDebugger.ts

@@ -72,7 +72,7 @@ class IotjsDebugSession extends DebugSession {
   ): void {
     // This debug adapter implements the configurationDoneRequest.
     response.body.supportsConfigurationDoneRequest = true;
-    response.body.supportsFunctionBreakpoints = false;
+    response.body.supportsFunctionBreakpoints = true;
     response.body.supportsEvaluateForHovers = false;
     response.body.supportsStepBack = false;
     response.body.supportsRestartRequest = false;
@@ -259,6 +259,76 @@ class IotjsDebugSession extends DebugSession {
     this.sendResponse(response);
   }
 
+  protected async setFunctionBreakPointsRequest(
+    response: DebugProtocol.SetFunctionBreakpointsResponse, args: DebugProtocol.SetFunctionBreakpointsArguments
+  ): Promise<void> {
+    const vscodeFunctionBreakpoints: DebugProtocol.FunctionBreakpoint[] = args.breakpoints;
+
+    try {
+      let persistingFBreakpoints: TemporaryBreakpoint[] = [];
+      let newFBreakpoints: TemporaryBreakpoint[] = [];
+      let undefinedFBreakpoins: TemporaryBreakpoint[] = [];
+
+      await Promise.all(this._protocolhandler.getSources().map(async (src, id) => {
+        const scriptId = id + 1;
+        const inactiveFBps: Breakpoint[] = this._protocolhandler.getInactiveFunctionBreakpointsByScriptId(scriptId);
+        const vscodeFunctionBreakpointNames: string[] = vscodeFunctionBreakpoints.map(b => b.name);
+
+        const newFBs = inactiveFBps.filter(b => vscodeFunctionBreakpointNames.indexOf(b.func.name) !== -1);
+
+        // Get the new breakpoints.
+        newFBreakpoints = [
+          ...newFBreakpoints,
+          ...await Promise.all(newFBs.map(async (breakpoint) => {
+            try {
+              await this._protocolhandler.updateBreakpoint(breakpoint, true);
+              return <TemporaryBreakpoint>{verified: true, line: breakpoint.line};
+            } catch (error) {
+              this.log(error.message, LOG_LEVEL.ERROR);
+              return <TemporaryBreakpoint>{verified: false, line: breakpoint.line, message: (<Error>error).message};
+            }
+          }))
+        ];
+
+        // Get the persists breakpoints.
+        const possibleFBs = this._protocolhandler.getPossibleFunctionBreakpointsByScriptId(scriptId);
+        persistingFBreakpoints = [
+          ...persistingFBreakpoints,
+          ...possibleFBs.filter(b => {
+            return newFBs.map(b => b.func.name).indexOf(b.func.name) === -1 &&
+                  vscodeFunctionBreakpointNames.indexOf(b.func.name) !== -1;
+          }).map(b => <TemporaryBreakpoint>{verified: true, line: b.line})
+        ];
+
+        // Get the removalbe breakpoints.
+        const activeFBs: Breakpoint[] = this._protocolhandler.getActiveFunctionBreakpointsByScriptId(scriptId);
+        const removeBps: Breakpoint[] = activeFBs.filter(b => {
+          return vscodeFunctionBreakpointNames.indexOf(b.func.name) === -1;
+        });
+
+        removeBps.forEach(async b => {
+          const jerryBreakpoint = this._protocolhandler.findBreakpoint(scriptId, b.line);
+          await this._protocolhandler.updateBreakpoint(jerryBreakpoint, false);
+        });
+
+        undefinedFBreakpoins = [
+          ...undefinedFBreakpoins,
+          ...vscodeFunctionBreakpoints.filter(b => {
+            return possibleFBs.map(p => p.func.name).indexOf(b.name) === -1;
+          }).map(b => <TemporaryBreakpoint>{verified: false, message: 'No function found'})
+        ];
+      }));
+
+      response.body = { breakpoints: [...persistingFBreakpoints, ...newFBreakpoints, ...undefinedFBreakpoins] };
+    } catch (error) {
+      this.log(error, LOG_LEVEL.ERROR);
+      this.sendErrorResponse(response, <Error>error);
+      return;
+    }
+
+    this.sendResponse(response);
+  }
+
   protected async evaluateRequest(
     response: DebugProtocol.EvaluateResponse, args: DebugProtocol.EvaluateArguments
   ): Promise<void> {

src/JerryProtocolHandler.ts

@@ -254,6 +254,11 @@ export class JerryDebugProtocolHandler {
     return array;
   }
 
+  public getSources(): ParsedSource[] {
+    // The first element is a dummy because sources is 1-indexed
+    return this.sources.slice(1);
+  }
+
   public getSource(scriptId: number): string {
     if (scriptId < this.sources.length) {
       return this.sources[scriptId].source || '';
@@ -646,6 +651,25 @@ export class JerryDebugProtocolHandler {
     return this.activeBreakpoints.filter(b => b.scriptId === scriptId);
   }
 
+  public getActiveFunctionBreakpointsByScriptId(scriptId: number): Breakpoint[] {
+    return this.getPossibleFunctionBreakpointsByScriptId(scriptId).filter(b => b.activeIndex !== -1);
+  }
+
+  public getInactiveFunctionBreakpointsByScriptId(scriptId: number): Breakpoint[] {
+    return this.getPossibleFunctionBreakpointsByScriptId(scriptId).filter(b => b.activeIndex === -1);
+  }
+
+  public getPossibleFunctionBreakpointsByScriptId(scriptId: number): Breakpoint[] {
+    if (scriptId <= 0 || scriptId >= this.lineLists.length) {
+      throw new Error('invalid script id');
+    }
+
+    const keys: string[] = Object.keys(this.functions).filter(f => this.functions[f].scriptId === scriptId);
+    const bps: Breakpoint[] = keys.map(key => this.functions[key].lines[Object.keys(this.functions[key].lines)[0]]);
+
+    return bps.length ? bps.filter(b => b.func.name !== '') : [];
+  }
+
   public evaluate(expression: string): Promise<any> {
     if (!this.lastBreakpointHit) {
       return Promise.reject(new Error('attempted eval while not at breakpoint'));
@@ -691,7 +715,7 @@ export class JerryDebugProtocolHandler {
     throw new Error('no breakpoint found');
   }
 
-  public updateBreakpoint(breakpoint: Breakpoint, enable: boolean): Promise<number> {
+  public updateBreakpoint(breakpoint: Breakpoint, enable: boolean): Promise<void> {
     let breakpointId;
 
     if (enable) {

src/test/JerryProtocolHandler.test.ts

@@ -366,6 +366,40 @@ suite('JerryProtocolHandler', () => {
         });
     });
 
+    suite('getSources', () => {
+        test('returns a sources array', () => {
+            const sources = [{
+                // Dummy, because the sources is 1-indexed
+            }, {
+                name: 'ble.js',
+                source: 'console.log("This is a module...");'
+            }, {
+                name: 'led-stripe.js',
+                source: 'const x = 10;'
+            }];
+
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).sources = sources;
+
+            const result = handler.getSources();
+            assert.strictEqual(result[0].name, 'ble.js');
+            assert.strictEqual(result[1].source, 'const x = 10;');
+            assert.strictEqual(result.length, 2);
+        });
+
+        test('returns an empty array', () => {
+            const sources = [{
+                // Dummy, because the sources is 1-indexed
+            }];
+
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).sources = sources;
+
+            const result = handler.getSources();
+            assert.strictEqual(result.length, 0);
+        });
+    });
+
     suite('evaluate', () => {
         test('sends single eval packet for short expressions', () => {
           const debugClient = {
@@ -455,6 +489,140 @@ suite('JerryProtocolHandler', () => {
         });
     });
 
+    suite('getActiveFunctionBreakpointsByScriptId', () => {
+        test('return a breakpoints array', () => {
+            const name = 'crane.js';
+            const scriptId = 11;
+            const func = {
+                scriptId,
+                lines: [
+                    {
+                        activeIndex: 3,
+                        func: { name }
+                    },
+                    {
+                        activeIndex: -1,
+                        func: { name }
+                    },
+                    {
+                        activeIndex: -1,
+                        func: { name }
+                    },
+                ],
+            };
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).functions = [ func ];
+            (handler as any).lineLists = {
+                [scriptId]: [[func], ['a', func], [func, 'b']],
+            };
+            const breakpoints = handler.getActiveFunctionBreakpointsByScriptId(scriptId);
+            assert.strictEqual(breakpoints[0].activeIndex, 3);
+            assert.strictEqual(breakpoints[0].func.name, name);
+            assert.strictEqual(breakpoints.length, 1);
+        });
+
+        test('throws error on invalid scriptId (0)', () => {
+            const scriptId = 0;
+            const handler = new JerryDebugProtocolHandler({});
+            assert.throws(() => handler.getActiveFunctionBreakpointsByScriptId(scriptId), 'invalid script id');
+        });
+
+        test('throws error on invalid scriptId (greater than linelist length)', () => {
+            const scriptId = 4;
+            const handler = new JerryDebugProtocolHandler({});
+            assert.throws(() => handler.getActiveFunctionBreakpointsByScriptId(scriptId), 'invalid script id');
+        });
+
+        test('return an empty array in case of no active functionbreakpoints', () => {
+            const name = 'lumbermill.js';
+            const scriptId = 1;
+            const func = {
+                scriptId,
+                lines: [
+                    {
+                        activeIndex: -1,
+                        func: { name }
+                    },
+                ],
+            };
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).functions = [ func ];
+            (handler as any).lineLists = {
+                [scriptId]: [[func], ['a', func], [func, 'b']],
+            };
+
+            const breakpoints = handler.getActiveFunctionBreakpointsByScriptId(scriptId);
+            assert.strictEqual(breakpoints.length, 0);
+        });
+    });
+
+    suite('getInactiveFunctionBreakpointsByScriptId', () => {
+        test('return a breakpoins array', () => {
+            const name = 'missing-data.js';
+            const scriptId = 9;
+            const func = {
+                scriptId,
+                lines: [
+                    {
+                        activeIndex: -1,
+                        func: { name }
+                    },
+                    {
+                        activeIndex: 4,
+                        func: { name }
+                    },
+                    {
+                        activeIndex: 5,
+                        func: { name }
+                    },
+                ],
+            };
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).functions = [ func ];
+            (handler as any).lineLists = {
+                [scriptId]: [[func], ['a', func], [func, 'b']],
+            };
+            const breakpoints = handler.getInactiveFunctionBreakpointsByScriptId(scriptId);
+            assert.strictEqual(breakpoints[0].activeIndex, -1);
+            assert.strictEqual(breakpoints[0].func.name, name);
+            assert.strictEqual(breakpoints.length, 1);
+        });
+
+        test('throws error on invalid scriptId (0)', () => {
+            const scriptId = 0;
+            const handler = new JerryDebugProtocolHandler({});
+            assert.throws(() => handler.getInactiveFunctionBreakpointsByScriptId(scriptId), 'invalid script id');
+        });
+
+        test('throws error on invalid scriptId (greater than linelist length)', () => {
+            const scriptId = 10;
+            const handler = new JerryDebugProtocolHandler({});
+            assert.throws(() => handler.getInactiveFunctionBreakpointsByScriptId(scriptId), 'invalid script id');
+        });
+
+        test('return an empty array in case of no inactive functionbreakpoints', () => {
+            const name = 'dust.js';
+            const scriptId = 7;
+            const func = {
+                scriptId,
+                lines: [
+                    {
+                        activeIndex: 4,
+                        func: { name }
+                    },
+                ],
+            };
+            const handler = new JerryDebugProtocolHandler({});
+            (handler as any).functions = [ func ];
+            (handler as any).lineLists = {
+                [scriptId]: [[func], ['a', func], [func, 'b']],
+            };
+
+            const breakpoints = handler.getInactiveFunctionBreakpointsByScriptId(scriptId);
+            assert.strictEqual(breakpoints.length, 0);
+        });
+    });
+
     suite('updateBreakpoint', () => {
         const debugClient = {
           send: sinon.spy(),