Add support for completionRequest

Author: felixfbecker

src/phpDebug.ts

@@ -143,6 +143,7 @@ class PhpDebugSession extends vscode.DebugSession {
             supportsEvaluateForHovers: false,
             supportsConditionalBreakpoints: true,
             supportsFunctionBreakpoints: true,
+            supportsCompletionsRequest: true,
             exceptionBreakpointFilters: [
                 {
                     filter: 'Notice',
@@ -706,6 +707,105 @@ class PhpDebugSession extends vscode.DebugSession {
         this.sendResponse(response);
     }
 
+    protected async completionsRequest(response: VSCodeDebugProtocol.CompletionsResponse, args: VSCodeDebugProtocol.CompletionsArguments) {
+        try {
+            if (!args.frameId) {
+                throw new Error('No stack frame given');
+            }
+            const text: string = args.text;
+            const lineIndex: number = args.line ? args.line - 1 : 0;
+            const lines: string[] = text.split('\n');
+            /** The text before the cursor */
+            const typed: string = [...lines.slice(0, Math.max(lineIndex - 1, 0)), lines[lineIndex].substring(0, args.column)].join('\n');
+            let i = typed.length;
+            let containerName: string;
+            let operator: string | undefined;
+            let query: string;
+            while (true) {
+                const substr = typed.substring(0, i);
+                if (/\[$/.test(substr)) {
+                    // Numeric array index
+                    operator = '[';
+                } else if (/\['$/.test(substr)) {
+                    // String array index
+                    operator = `['`;
+                } else if (/->$/.test(substr)) {
+                    operator = '->';
+                } else if (i > 0) {
+                    i--;
+                    continue;
+                }
+                query = typed.substr(i);
+                containerName = typed.substring(0, i);
+                break;
+            }
+            const frame = this._stackFrames.get(args.frameId);
+            const contexts = await frame.getContexts();
+            const targets: VSCodeDebugProtocol.CompletionItem[] = [];
+            if (!containerName || !operator) {
+                const responses = await Promise.all(contexts.map(context => context.getProperties()));
+                for (const properties of responses) {
+                    for (const property of properties) {
+                        if (property.name.toLowerCase().startsWith(query)) {
+                            targets.push({label: property.name, type: 'variable', start: i, length: property.name.length});
+                        }
+                    }
+                }
+            } else {
+                // Search all contexts
+                for (const context of contexts) {
+                    let response: xdebug.PropertyGetResponse | undefined;
+                    try {
+                        response = await frame.connection.sendPropertyGetCommand({context, fullName: containerName});
+                    } catch (err) {
+                        // ignore
+                    }
+                    if (response) {
+                        for (const property of response.children) {
+                            if (property.name.toLowerCase().startsWith(query)) {
+                                let type: VSCodeDebugProtocol.CompletionItemType | undefined;
+                                let text: string = property.name;
+                                if (operator === '->') {
+                                    // Object
+                                    type = 'property';
+                                } else if (operator[0] === '[') {
+                                    // Array
+                                    if (parseInt(property.name) + '' === property.name) {
+                                        // Numeric index
+                                        if (operator[1] === `'`) {
+                                            continue;
+                                        }
+                                        type = 'value';
+                                        text += ']';
+                                    } else {
+                                        // String index
+                                        if (operator[1] !== `'`) {
+                                            if (query) {
+                                                continue;
+                                            } else {
+                                                text = `'` + text;
+                                            }
+                                        }
+                                        type = 'text';
+                                        text += `']`;
+                                    }
+                                }
+                                targets.push({label: property.name, text, type, start: i, length: property.name.length });
+                            }
+                        }
+                        // If we found the variable in one context (typically Locals), abort
+                        break;
+                    }
+                }
+            }
+            response.body = {targets};
+        } catch (err) {
+            this.sendErrorResponse(response, err);
+            return;
+        }
+        this.sendResponse(response);
+    }
+
     protected async continueRequest(response: VSCodeDebugProtocol.ContinueResponse, args: VSCodeDebugProtocol.ContinueArguments) {
         let xdebugResponse: xdebug.StatusResponse | undefined;
         try {

src/xdebugConnection.ts

@@ -476,7 +476,7 @@ export class PropertyGetResponse extends Response {
      * @param  {XMLDocument} document
      * @param  {Property} property
      */
-    constructor(document: XMLDocument, property: Property) {
+    constructor(document: XMLDocument, property: {context: Context}) {
         super(document, property.context.stackFrame.connection);
         this.children = Array.from(document.documentElement.firstChild.childNodes).map((propertyNode: Element) => new Property(propertyNode, property.context));
     }
@@ -782,7 +782,7 @@ export class Connection extends DbgpConnection {
     }
 
     /** Sends a property_get command */
-    public async sendPropertyGetCommand(property: Property): Promise<PropertyGetResponse> {
+    public async sendPropertyGetCommand(property: {context: Context, fullName: string}): Promise<PropertyGetResponse> {
         const escapedFullName = '"' + property.fullName.replace(/("|\\)/g, '\\$1') + '"';
         return new PropertyGetResponse(await this._enqueueCommand('property_get', `-d ${property.context.stackFrame.level} -c ${property.context.id} -n ${escapedFullName}`), property);
     }