Implement codeLens

client/src/ui/BitbakeCommands.ts

@@ -52,6 +52,8 @@ export function registerBitbakeCommands (context: vscode.ExtensionContext, bitba
     vscode.commands.registerCommand('bitbake.stop-toaster', async () => { await stopToaster(bitBakeProjectScanner.bitbakeDriver) }),
     vscode.commands.registerCommand('bitbake.clear-workspace-state', async () => { await clearAllWorkspaceState(context) }),
     vscode.commands.registerCommand('bitbake.examine-dependency-taskexp', async (uri) => { await examineDependenciesTaskexp(bitbakeWorkspace, bitBakeProjectScanner, uri) }),
+    vscode.commands.registerCommand('bitbake.codeLens.showReferences', async (uri, position) => { await showReferences(uri, position) }),
+
     // Handles enqueued parsing requests (onSave)
     vscode.tasks.onDidEndTask((e) => {
       if (e.execution.task.name === 'Bitbake: Parse') {
@@ -70,6 +72,21 @@ export function registerBitbakeCommands (context: vscode.ExtensionContext, bitba
   )
 }
 
+async function showReferences (uri: any, position: any): Promise<void> {
+  if (typeof uri !== 'string' || position === undefined) {
+    return
+  }
+
+  let _position: vscode.Position
+  try {
+    _position = new vscode.Position(position.line, position.character)
+    const locations = await vscode.commands.executeCommand('vscode.executeReferenceProvider', vscode.Uri.parse(uri), position)
+    await vscode.commands.executeCommand('editor.action.showReferences', vscode.Uri.parse(uri), _position, locations)
+  } catch (error: any) {
+    void vscode.window.showErrorMessage('Failed to show references: ' + JSON.stringify(error))
+  }
+}
+
 async function clearAllWorkspaceState (context: vscode.ExtensionContext, key?: string): Promise<void> {
   for (const key of context.workspaceState.keys()) {
     await context.workspaceState.update(key, undefined).then(

package.json

@@ -206,6 +206,11 @@
 				"type": "boolean",
 				"default": false,
 				"description": "Turn on this setting to stop this extension from modifying the VS Code configuration of the workspace. Note that this will also disable some features related to embedded Python and Shell code."
+			},
+			"bitbake.enableCodeLensReferencesOnFunctions": {
+				"type": "boolean",
+				"default": false,
+				"description": "Enable or disable the CodeLens references for functions in BitBake files."
 			}
 		  }
 		},

server/src/__tests__/analyzer.test.ts

@@ -46,7 +46,7 @@ describe('analyze', () => {
       document: FIXTURE_DOCUMENT.DECLARATION
     })
 
-    const globalDeclarations = analyzer.getGlobalDeclarationSymbols(DUMMY_URI)
+    const globalDeclarations = analyzer.getGlobalDeclarationSymbolsForUri(DUMMY_URI)
 
     expect(globalDeclarations).toEqual(
       expect.arrayContaining([
@@ -261,7 +261,7 @@ describe('sourceIncludeFiles', () => {
     analyzer.extractIncludeFileUris(uri)
 
     const symbols = analyzer.getIncludeUrisForUri(uri).map((includeUri) => {
-      return analyzer.getGlobalDeclarationSymbols(includeUri)
+      return analyzer.getGlobalDeclarationSymbolsForUri(includeUri)
     }).flat()
 
     expect(symbols).toEqual(
@@ -334,7 +334,7 @@ describe('declarations', () => {
       uri
     })
 
-    const symbols = analyzer.getGlobalDeclarationSymbols(uri)
+    const symbols = analyzer.getGlobalDeclarationSymbolsForUri(uri)
 
     let occurances = 0
     symbols.forEach((symbol) => {

server/src/connectionHandlers/onCodeLens.ts

@@ -0,0 +1,38 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2023 Savoir-faire Linux. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as LSP from 'vscode-languageserver/node'
+import { analyzer } from '../tree-sitter/analyzer'
+
+export async function onCodeLensHandler (params: LSP.CodeLensParams, enableCodeLensReferencesOnFunctions: boolean): Promise<LSP.CodeLens[]> {
+  const codeLenses: LSP.CodeLens[] = []
+  const uri = params.textDocument.uri
+
+  if (!enableCodeLensReferencesOnFunctions) {
+    return []
+  }
+
+  const allSymbols = analyzer.getGlobalDeclarationSymbolsForUri(uri)
+  allSymbols.forEach((symbol) => {
+    if (symbol.kind === LSP.SymbolKind.Function) {
+      const codeLens = LSP.CodeLens.create(symbol.location.range)
+
+      codeLens.command = {
+        title: 'Show References',
+        command: 'bitbake.codeLens.showReferences',
+        arguments: [uri, symbol.location.range.start]
+      }
+
+      codeLens.data = { uri, position: symbol.location.range.start }
+
+      codeLenses.push(codeLens)
+    }
+  })
+  return codeLenses
+}
+
+export function onCodeLensResolveHandler (codeLens: LSP.CodeLens): LSP.CodeLens {
+  return codeLens
+}

server/src/connectionHandlers/onCompletion.ts

@@ -238,7 +238,7 @@ const allCommonDirectoriesCompletionItems: CompletionItem[] = Array.from(commonD
 function getSymbolCompletionItems (word: string | null): CompletionItem[] {
   if (word !== null) {
     const uniqueSymbolSet = new Set()
-    const globalDeclarationSymbols = analyzer.getGlobalDeclarationSymbols(documentUri).filter(symbol => {
+    const globalDeclarationSymbols = analyzer.getGlobalDeclarationSymbolsForUri(documentUri).filter(symbol => {
       if (!uniqueSymbolSet.has(symbol.name)) {
         uniqueSymbolSet.add(symbol.name)
         return true
@@ -397,7 +397,7 @@ function convertExtraSymbolsToCompletionItems (uri: string): CompletionItem[] {
   logger.debug(`[onCompletion] convertSymbolsToCompletionItems: ${uri}`)
   let completionItems: CompletionItem[] = []
   analyzer.getIncludeUrisForUri(uri).map((includeUri) => {
-    return analyzer.getGlobalDeclarationSymbols(includeUri)
+    return analyzer.getGlobalDeclarationSymbolsForUri(includeUri)
   })
     .flat()
     .reduce<BitbakeSymbolInformation[]>((acc, symbol) => {

server/src/connectionHandlers/onDefinition.ts

@@ -162,10 +162,10 @@ export function getAllDefinitionSymbolsForSymbolAtPoint (uri: string, word: stri
     return []
   }
   const allDeclarationSymbols = [
-    ...analyzer.getGlobalDeclarationSymbols(uri)
+    ...analyzer.getGlobalDeclarationSymbolsForUri(uri)
   ]
   analyzer.getIncludeUrisForUri(uri)?.forEach((includeFileUri) => {
-    allDeclarationSymbols.push(...analyzer.getGlobalDeclarationSymbols(includeFileUri))
+    allDeclarationSymbols.push(...analyzer.getGlobalDeclarationSymbolsForUri(includeFileUri))
   })
 
   return allDeclarationSymbols.filter(symbol => symbol.name === word && symbol.kind === symbolAtPoint?.kind)

server/src/connectionHandlers/onHover.ts

@@ -28,7 +28,7 @@ export async function onHoverHandler (params: HoverParams): Promise<Hover | null
 
   // Show documentation of a bitbake variable
   // Triggers on global declaration expressions like "VAR = 'foo'" and inside variable expansion like "FOO = ${VAR}" but skip the ones like "python VAR(){}"
-  const canShowHoverDefinitionForVariableName: boolean = (analyzer.getGlobalDeclarationSymbols(textDocument.uri).some((symbol) => symbol.name === word) && analyzer.isIdentifierOfVariableAssignment(params)) || analyzer.isVariableExpansion(textDocument.uri, position.line, position.character) || analyzer.isPythonDatastoreVariable(textDocument.uri, position.line, position.character) || analyzer.isBashVariableExpansion(textDocument.uri, position.line, position.character)
+  const canShowHoverDefinitionForVariableName: boolean = (analyzer.getGlobalDeclarationSymbolsForUri(textDocument.uri).some((symbol) => symbol.name === word) && analyzer.isIdentifierOfVariableAssignment(params)) || analyzer.isVariableExpansion(textDocument.uri, position.line, position.character) || analyzer.isPythonDatastoreVariable(textDocument.uri, position.line, position.character) || analyzer.isBashVariableExpansion(textDocument.uri, position.line, position.character)
   if (canShowHoverDefinitionForVariableName) {
     const found = [
       ...bitBakeDocScanner.bitbakeVariableInfo.filter((bitbakeVariable) => !bitBakeDocScanner.yoctoVariableInfo.some(yoctoVariable => yoctoVariable.name === bitbakeVariable.name)),
@@ -121,11 +121,11 @@ export async function onHoverHandler (params: HoverParams): Promise<Hover | null
 }
 
 function getGlobalSymbolComments (uri: string, word: string, currentSymbolAtPoint: BitbakeSymbolInformation): string | null {
-  const localSymbolsWithComments = analyzer.getGlobalDeclarationSymbols(uri).filter((symbol) => symbol.name === word).filter((symbol) => symbol.commentsAbove.length > 0)
+  const localSymbolsWithComments = analyzer.getGlobalDeclarationSymbolsForUri(uri).filter((symbol) => symbol.name === word).filter((symbol) => symbol.commentsAbove.length > 0)
   const externalSymbolsWithComments: BitbakeSymbolInformation[] = []
 
   analyzer.getIncludeUrisForUri(uri).forEach((includeFileUri) => {
-    externalSymbolsWithComments.push(...analyzer.getGlobalDeclarationSymbols(includeFileUri).filter((symbol) => symbol.name === word).filter((symbol) => symbol.commentsAbove.length > 0))
+    externalSymbolsWithComments.push(...analyzer.getGlobalDeclarationSymbolsForUri(includeFileUri).filter((symbol) => symbol.name === word).filter((symbol) => symbol.commentsAbove.length > 0))
   })
   const priority = ['.bbclass', '.conf', '.inc', '.bb', '.bbappend']
 

server/src/server.ts

@@ -35,14 +35,15 @@ import { expandSettingPath } from './lib/src/BitbakeSettings'
 import { onReferenceHandler } from './connectionHandlers/onReference'
 import { type BitbakeScanResult } from './lib/src/types/BitbakeScanResult'
 import { onPrepareRenameHandler, onRenameRequestHandler } from './connectionHandlers/onRename'
+import { onCodeLensHandler, onCodeLensResolveHandler } from './connectionHandlers/onCodeLens'
 
 // Create a connection for the server. The connection uses Node's IPC as a transport
 export const connection: Connection = createConnection(ProposedFeatures.all)
 setDefinitionsConnection(connection)
 const documents = new TextDocuments<TextDocument>(TextDocument)
 let workspaceFolder: string | undefined
 let pokyFolder: string | undefined
-
+let enableCodeLensReferencesOnFunctions: boolean = false
 const disposables: Disposable[] = []
 
 let currentActiveTextDocument: TextDocument = TextDocument.create(
@@ -111,13 +112,17 @@ disposables.push(
         },
         renameProvider: {
           prepareProvider: true
+        },
+        codeLensProvider: {
+          resolveProvider: true
         }
       }
     }
   }),
 
   connection.onDidChangeConfiguration((change) => {
     logger.level = change.settings.bitbake?.loggingLevel ?? logger.level
+    enableCodeLensReferencesOnFunctions = change.settings.bitbake?.enableCodeLensReferencesOnFunctions ?? enableCodeLensReferencesOnFunctions
     const bitbakeFolder = expandSettingPath(change.settings.bitbake?.pathToBitbakeFolder, { workspaceFolder })
     if (bitbakeFolder !== undefined) {
       pokyFolder = path.join(bitbakeFolder, '..') // We assume BitBake is into Poky
@@ -156,6 +161,12 @@ disposables.push(
     analyzer.clearRecipeLocalFiles()
   }),
 
+  connection.onCodeLens(
+    async (params) => await onCodeLensHandler(params, enableCodeLensReferencesOnFunctions)
+  ),
+
+  connection.onCodeLensResolve(onCodeLensResolveHandler),
+
   connection.onRequest(
     RequestMethod.EmbeddedLanguageTypeOnPosition,
     async ({ uriString, position }: RequestParams['EmbeddedLanguageTypeOnPosition']): RequestResult['EmbeddedLanguageTypeOnPosition'] => {

server/src/tree-sitter/analyzer.ts

@@ -90,7 +90,7 @@ export default class Analyzer {
 
   public getAllSymbols (uri: string): BitbakeSymbolInformation[] {
     return [
-      ...this.getGlobalDeclarationSymbols(uri),
+      ...this.getGlobalDeclarationSymbolsForUri(uri),
       ...this.getVariableExpansionSymbols(uri),
       ...this.getPythonDatastoreVariableSymbols(uri)
     ]
@@ -185,7 +185,7 @@ export default class Analyzer {
     return { variableExpansionSymbols, pythonDatastoreVariableSymbols }
   }
 
-  public getGlobalDeclarationSymbols (uri: string): BitbakeSymbolInformation[] {
+  public getGlobalDeclarationSymbolsForUri (uri: string): BitbakeSymbolInformation[] {
     const analyzedDocument = this.uriToAnalyzedDocument[uri]
     if (analyzedDocument !== undefined) {
       const { globalDeclarations } = analyzedDocument