Implement function breakpoints

Author: felixfbecker

README.md

@@ -35,6 +35,7 @@ What is supported?
 ------------------
  - Line breakpoints
  - Conditional breakpoints
+ - Function breakpoints
  - Step over, step in, step out
  - Break on entry
  - Breaking on uncaught exceptions and errors / warnings / notices

src/phpDebug.ts

@@ -129,6 +129,7 @@ class PhpDebugSession extends vscode.DebugSession {
         response.body.supportsConfigurationDoneRequest = true;
         response.body.supportsEvaluateForHovers = false;
         response.body.supportsConditionalBreakpoints = true;
+        response.body.supportsFunctionBreakpoints = true;
         response.body.exceptionBreakpointFilters = [
             {
                 filter: 'Notice',
@@ -426,6 +427,56 @@ class PhpDebugSession extends vscode.DebugSession {
         });
     }
 
+    protected setFunctionBreakPointsRequest(response: VSCodeDebugProtocol.SetFunctionBreakpointsResponse, args: VSCodeDebugProtocol.SetFunctionBreakpointsArguments): void {
+        const connections = Array.from(this._connections.values());
+        response.body = { breakpoints: [] };
+        // this is returned to VS Code
+        let vscodeBreakpoints: VSCodeDebugProtocol.Breakpoint[];
+        let breakpointsSetPromise: Promise<any>;
+        if (connections.length === 0) {
+            // if there are no connections yet, we cannot verify any breakpoint
+            vscodeBreakpoints = args.breakpoints.map(breakpoint => ({verified: false, message: 'No connection'}));
+            breakpointsSetPromise = Promise.resolve();
+        } else {
+            vscodeBreakpoints = [];
+            // for all connections
+            breakpointsSetPromise = Promise.all(connections.map((connection, connectionIndex) =>
+                // clear breakpoints for this file
+                connection.sendBreakpointListCommand()
+                    .then(response => Promise.all(
+                        response.breakpoints
+                            .filter(breakpoint => breakpoint instanceof xdebug.CallBreakpoint)
+                            .map(breakpoint => breakpoint.remove())
+                    ))
+                    .then(() => Promise.all(
+                        args.breakpoints.map(functionBreakpoint =>
+                            connection.sendBreakpointSetCommand(new xdebug.CallBreakpoint(functionBreakpoint.name, functionBreakpoint.condition))
+                                .then(xdebugResponse => {
+                                    // only capture each breakpoint once
+                                    if (connectionIndex === 0) {
+                                        vscodeBreakpoints.push({verified: true, id: xdebugResponse.breakpointId});
+                                    }
+                                })
+                                .catch(error => {
+                                    // only capture each breakpoint once
+                                    if (connectionIndex === 0) {
+                                        vscodeBreakpoints.push({verified: false, message: error.message});
+                                    }
+                                })
+                        )
+                    ))
+            ));
+        }
+        breakpointsSetPromise
+            .then(() => {
+                response.body = {breakpoints: vscodeBreakpoints};
+                this.sendResponse(response);
+            })
+            .catch(error => {
+                this.sendErrorResponse(response, error);
+            });
+    }
+
     /** Executed after all breakpoints have been set by VS Code */
     protected configurationDoneRequest(response: VSCodeDebugProtocol.ConfigurationDoneResponse, args: VSCodeDebugProtocol.ConfigurationDoneArguments): void {
         for (const connection of Array.from(this._waitingConnections)) {

src/xdebugConnection.ts

@@ -132,6 +132,7 @@ export abstract class Breakpoint {
             case 'exception': return new ExceptionBreakpoint(breakpointNode, connection);
             case 'line': return new LineBreakpoint(breakpointNode, connection);
             case 'conditional': return new ConditionalBreakpoint(breakpointNode, connection);
+            case 'call': return new CallBreakpoint(breakpointNode, connection);
         }
     }
     /** Constructs a breakpoint object from an XML node from a XDebug response */
@@ -181,6 +182,32 @@ export class LineBreakpoint extends Breakpoint {
     }
 }
 
+/** class for call breakpoints. Returned from a breakpoint_list or passed to sendBreakpointSetCommand */
+export class CallBreakpoint extends Breakpoint {
+    /** the function to break on */
+    fn: string;
+    /** optional expression that must evaluate to true */
+    expression: string;
+    /** constructs a call breakpoint from an XML node */
+    constructor(breakpointNode: Element, connection: Connection);
+    /** contructs a call breakpoint for passing to sendSetBreakpointCommand */
+    constructor(fn: string, expression?: string);
+    constructor() {
+        if (typeof arguments[0] === 'object') {
+            const breakpointNode: Element = arguments[0];
+            const connection: Connection = arguments[1];
+            super(breakpointNode, connection);
+            this.fn = breakpointNode.getAttribute('function');
+            this.expression = breakpointNode.getAttribute('expression'); // Base64 encoded?
+        } else {
+            // construct from arguments
+            this.fn = arguments[0];
+            this.expression = arguments[1];
+            super('call');
+        }
+    }
+}
+
 /** class for exception breakpoints. Returned from a breakpoint_list or passed to sendBreakpointSetCommand */
 export class ExceptionBreakpoint extends Breakpoint {
     /** The Exception name to break on. Can also contain wildcards. */
@@ -668,6 +695,9 @@ export class Connection extends DbgpConnection {
                 args += ` -n ${breakpoint.line}`;
             }
             data = breakpoint.expression;
+        } else if (breakpoint instanceof CallBreakpoint) {
+            args += ` -m ${breakpoint.fn}`;
+            data = breakpoint.expression;
         }
         return this._enqueueCommand('breakpoint_set', args, data).then(document => new BreakpointSetResponse(document, this));
     }