feat: improve hover support (#689)

* Implement basic regex EvaluatableExpressionProvider

* Ignoring codecov.yml in vscodeignore.

* Code style.

* Change features test.

* Evaluate hover by property_get instead of eval. Add Property Get by name.

* Additional tests for evaluation (hover).

* Changelog.

Author: zobo

.vscodeignore

@@ -25,3 +25,4 @@ tsconfig.json
 tslint.json
 renovate.json
 .github
+codecov.yml

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 - When `env` is specified in launch configuration it will be merged the process environment.
 - Set variable support.
+- Improved hover support
 
 ## [1.22.0]
 

src/extension.ts

@@ -70,6 +70,26 @@ export function activate(context: vscode.ExtensionContext) {
             },
         })
     )
+    context.subscriptions.push(
+        vscode.languages.registerEvaluatableExpressionProvider('php', {
+            async provideEvaluatableExpression(
+                document: vscode.TextDocument,
+                position: vscode.Position,
+                token: CancellationToken
+            ): Promise<ProviderResult<vscode.EvaluatableExpression>> {
+                // see https://www.php.net/manual/en/language.variables.basics.php
+                // const wordRange = document.getWordRangeAtPosition(position, /\$([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)((->(?1))|\[(\d+|'[^']+'|"[^"]+"|(?0))\])*/)
+                const wordRange = document.getWordRangeAtPosition(
+                    position,
+                    /\$[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*(->[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)*/
+                )
+                if (wordRange) {
+                    return new vscode.EvaluatableExpression(wordRange)
+                }
+                return undefined // nothing evaluatable found under mouse
+            },
+        })
+    )
 
     context.subscriptions.push(
         vscode.commands.registerCommand('php.debug.debugPhpFile', async (uri: vscode.Uri) => {

src/phpDebug.ts

@@ -190,7 +190,7 @@ class PhpDebugSession extends vscode.DebugSession {
     ): void {
         response.body = {
             supportsConfigurationDoneRequest: true,
-            supportsEvaluateForHovers: false,
+            supportsEvaluateForHovers: true,
             supportsConditionalBreakpoints: true,
             supportsFunctionBreakpoints: true,
             supportsLogPoints: true,
@@ -1197,15 +1197,34 @@ class PhpDebugSession extends vscode.DebugSession {
             if (!this._stackFrames.has(args.frameId)) {
                 throw new Error(`Unknown frameId ${args.frameId}`)
             }
-            const connection = this._stackFrames.get(args.frameId)!.connection
-            const { result } = await connection.sendEvalCommand(args.expression)
+            const stackFrame = this._stackFrames.get(args.frameId)!
+            const connection = stackFrame.connection
+            let result: xdebug.BaseProperty | null = null
+            if (args.context === 'hover') {
+                // try to get variable from property_get
+                const ctx = await stackFrame.getContexts() // TODO CACHE THIS
+                const response = await connection.sendPropertyGetNameCommand(args.expression, ctx[0])
+                if (response.property) {
+                    result = response.property
+                }
+            } else {
+                const response = await connection.sendEvalCommand(args.expression)
+                if (response.result) {
+                    result = response.result
+                }
+            }
+
             if (result) {
                 const displayValue = formatPropertyValue(result)
                 let variablesReference: number
                 // if the property has children, generate a variable ID and save the property (including children) so VS Code can request them
                 if (result.hasChildren || result.type === 'array' || result.type === 'object') {
                     variablesReference = this._variableIdCounter++
-                    this._evalResultProperties.set(variablesReference, result)
+                    if (result instanceof xdebug.Property) {
+                        this._properties.set(variablesReference, result)
+                    } else {
+                        this._evalResultProperties.set(variablesReference, result)
+                    }
                 } else {
                     variablesReference = 0
                 }

src/test/adapter.ts

@@ -25,7 +25,7 @@ describe('PHP Debug Adapter', () => {
         it('should return supported features', async () => {
             const response = await client.initializeRequest()
             assert.equal(response.body!.supportsConfigurationDoneRequest, true)
-            assert.equal(response.body!.supportsEvaluateForHovers, false)
+            assert.equal(response.body!.supportsEvaluateForHovers, true)
             assert.equal(response.body!.supportsConditionalBreakpoints, true)
             assert.equal(response.body!.supportsFunctionBreakpoints, true)
         })
@@ -740,8 +740,53 @@ describe('PHP Debug Adapter', () => {
     })
 
     describe('evaluation', () => {
-        it('should return the eval result')
-        it('should return variable references for structured results')
+        it('should return the eval result', async () => {
+            const program = path.join(TEST_PROJECT, 'variables.php')
+
+            client.launch({
+                program,
+            })
+            await client.waitForEvent('initialized')
+            await client.setBreakpointsRequest({ source: { path: program }, breakpoints: [{ line: 19 }] })
+            await client.configurationDoneRequest()
+            const { frame } = await assertStoppedLocation('breakpoint', program, 19)
+
+            const response = (
+                await client.evaluateRequest({
+                    context: 'hover',
+                    frameId: frame.id,
+                    expression: '$anInt',
+                })
+            ).body
+
+            assert.equal(response.result, '123')
+            assert.equal(response.variablesReference, 0)
+        })
+        it('should return variable references for structured results', async () => {
+            const program = path.join(TEST_PROJECT, 'variables.php')
+
+            client.launch({
+                program,
+            })
+            await client.waitForEvent('initialized')
+            await client.setBreakpointsRequest({ source: { path: program }, breakpoints: [{ line: 19 }] })
+            await client.configurationDoneRequest()
+            const { frame } = await assertStoppedLocation('breakpoint', program, 19)
+
+            const response = (
+                await client.evaluateRequest({
+                    context: 'hover',
+                    frameId: frame.id,
+                    expression: '$anArray',
+                })
+            ).body
+
+            assert.equal(response.result, 'array(3)')
+            assert.notEqual(response.variablesReference, 0)
+            const vars = await client.variablesRequest({ variablesReference: response.variablesReference })
+            assert.deepEqual(vars.body.variables[0].name, '0')
+            assert.deepEqual(vars.body.variables[0].value, '1')
+        })
     })
 
     describe.skip('output events', () => {

src/xdebugConnection.ts

@@ -640,16 +640,30 @@ export class PropertyGetResponse extends Response {
     children: Property[]
     /**
      * @param  {XMLDocument} document
-     * @param  {Property} property
+     * @param  {Context} context
      */
-    constructor(document: XMLDocument, property: Property) {
-        super(document, property.context.stackFrame.connection)
+    constructor(document: XMLDocument, context: Context) {
+        super(document, context.stackFrame.connection)
         this.children = Array.from(document.documentElement.firstChild!.childNodes).map(
-            (propertyNode: Element) => new Property(propertyNode, property.context)
+            (propertyNode: Element) => new Property(propertyNode, context)
         )
     }
 }
 
+/** The response to a property_get by name command */
+export class PropertyGetNameResponse extends Response {
+    /** The property being resolved */
+    property: Property
+    /**
+     * @param  {XMLDocument} document
+     * @param  {Context} context
+     */
+    constructor(document: XMLDocument, context: Context) {
+        super(document, context.stackFrame.connection)
+        this.property = new Property(<Element>document.documentElement.firstChild!, context)
+    }
+}
+
 /** class for properties returned from eval commands. These don't have a full name or an ID, but have all children already inlined. */
 export class EvalResultProperty extends BaseProperty {
     children: EvalResultProperty[]
@@ -1045,7 +1059,19 @@ export class Connection extends DbgpConnection {
                 'property_get',
                 `-d ${property.context.stackFrame.level} -c ${property.context.id} -n ${escape(property.fullName)}`
             ),
-            property
+            property.context
+        )
+    }
+
+    /** Sends a property_get by name command */
+    public async sendPropertyGetNameCommand(name: String, context: Context): Promise<PropertyGetNameResponse> {
+        const escapedFullName = '"' + name.replace(/("|\\)/g, '\\$1') + '"'
+        return new PropertyGetNameResponse(
+            await this._enqueueCommand(
+                'property_get',
+                `-d ${context.stackFrame.level} -c ${context.id} -n ${escapedFullName}`
+            ),
+            context
         )
     }