Feat: Go to definition for uris in string content

server/src/__tests__/definition.test.ts

@@ -6,7 +6,7 @@
 import { analyzer } from '../tree-sitter/analyzer'
 import { generateParser } from '../tree-sitter/parser'
 import { onDefinitionHandler } from '../connectionHandlers/onDefinition'
-import { FIXTURE_DOCUMENT, DUMMY_URI, FIXTURE_URI } from './fixtures/fixtures'
+import { FIXTURE_DOCUMENT, DUMMY_URI, FIXTURE_URI, FIXTURE_FOLDER } from './fixtures/fixtures'
 import path from 'path'
 import { bitBakeProjectScannerClient } from '../BitbakeProjectScannerClient'
 
@@ -238,4 +238,42 @@ describe('on definition', () => {
 
     expect(shouldNotWork).toEqual([])
   })
+
+  it('provides go to definition for uris found in the string content', async () => {
+    await analyzer.analyze({
+      uri: DUMMY_URI,
+      document: FIXTURE_DOCUMENT.DIRECTIVE
+    })
+
+    analyzer.workspaceFolders = [{ uri: FIXTURE_FOLDER, name: 'test' }]
+
+    const shouldWork1 = onDefinitionHandler({
+      textDocument: {
+        uri: DUMMY_URI
+      },
+      position: {
+        line: 12,
+        character: 13
+      }
+    })
+
+    const shouldWork2 = onDefinitionHandler({
+      textDocument: {
+        uri: DUMMY_URI
+      },
+      position: {
+        line: 13,
+        character: 10
+      }
+    })
+
+    expect(shouldWork1).toEqual([
+      {
+        uri: FIXTURE_URI.FOO_INC,
+        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+      }
+    ])
+
+    expect(shouldWork2).toEqual(shouldWork1)
+  })
 })

server/src/__tests__/fixtures/directive.bb

@@ -8,4 +8,7 @@ FOO = '${APPEND}'
 SYMBOL_IN_STRING = 'hover is a package ${FOO} \
         parentFolder/hover should also be seen as symbol \
         this hover too, other words should not. \
-        '
+        '
+
+SRC_URI = 'file://foo.inc \
+        file://foo.inc'

server/src/__tests__/fixtures/fixtures.ts

@@ -12,7 +12,7 @@ import path from 'path'
 import fs from 'fs'
 import { TextDocument } from 'vscode-languageserver-textdocument'
 
-const FIXTURE_FOLDER = path.join(__dirname, './')
+export const FIXTURE_FOLDER = path.join(__dirname, './')
 
 type FIXTURE_URI_KEY = keyof typeof FIXTURE_URI
 

server/src/connectionHandlers/onDefinition.ts

@@ -10,6 +10,7 @@ import { type DirectiveStatementKeyword } from '../lib/src/types/directiveKeywor
 import { bitBakeProjectScannerClient } from '../BitbakeProjectScannerClient'
 import path, { type ParsedPath } from 'path'
 import { type ElementInfo } from '../lib/src/types/BitbakeScanResult'
+import fs from 'fs'
 
 export function onDefinitionHandler (textDocumentPositionParams: TextDocumentPositionParams): Definition | null {
   const { textDocument: { uri: documentUri }, position } = textDocumentPositionParams
@@ -72,16 +73,38 @@ export function onDefinitionHandler (textDocumentPositionParams: TextDocumentPos
     }
     // Symbols in string content
     if (analyzer.isStringContent(documentUri, position.line, position.character)) {
-      const allSymbolsFoundAtPosition = analyzer.getSymbolInStringContentForPosition(documentUri, position.line, position.character)
-      if (allSymbolsFoundAtPosition !== undefined) {
-        allSymbolsFoundAtPosition.forEach((symbol) => {
-          definitions.push({
-            uri: symbol.location.uri,
-            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
-          })
-        })
-        return definitions
+      const wholeWordRegex = /(?<![-.:])\b(\w+)\b(?![-.:])/g
+      const uriRegex = /(file:\/\/)(?<uri>.*)\b/g
+      const [uriAtPosition] = analyzer.getSymbolsInStringContent(documentUri, position.line, position.character, uriRegex)
+      if (uriAtPosition !== undefined) {
+        const { workspaceFolders } = analyzer
+        if (workspaceFolders !== undefined && workspaceFolders !== null) {
+          for (const workspaceFolder of workspaceFolders) {
+            const filePath = findFileInDirectory(workspaceFolder.uri.replace('file://', ''), uriAtPosition.name)
+            if (filePath !== null) {
+              definitions.push(
+                {
+                  uri: 'file://' + filePath,
+                  range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+                }
+              )
+              break
+            }
+          }
+          return definitions
+        }
       }
+
+      const allSymbolsAtPosition = analyzer.getSymbolsInStringContent(documentUri, position.line, position.character, wholeWordRegex)
+
+      allSymbolsAtPosition.forEach((symbol) => {
+        definitions.push({
+          uri: symbol.location.uri,
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        })
+      })
+
+      return definitions
     }
   }
 
@@ -133,3 +156,22 @@ function createDefinitionLocationForPathInfo (path: ParsedPath): Location {
 
   return location
 }
+
+function findFileInDirectory (dir: string, fileName: string): string | null {
+  try {
+    const filePaths = fs.readdirSync(dir).map(name => path.join(dir, name))
+    for (const filePath of filePaths) {
+      if (fs.statSync(filePath).isDirectory()) {
+        const result = findFileInDirectory(filePath, fileName)
+        if (result !== null) return result
+      } else if (path.basename(filePath) === fileName) {
+        return filePath
+      }
+    }
+  } catch {
+    logger.debug(`[findFileInDirectory] ${dir} not found`)
+    return null
+  }
+
+  return null
+}

server/src/server.ts

@@ -61,6 +61,7 @@ connection.onInitialize(async (params: InitializeParams): Promise<InitializeResu
 
   const parser = await generateParser()
   analyzer.initialize(parser)
+  analyzer.workspaceFolders = params.workspaceFolders
 
   bitBakeProjectScannerClient.onChange.on('scanReady', () => {
     logger.debug('[On scanReady] Analyzing the current document again...')

server/src/tree-sitter/analyzer.ts

@@ -13,7 +13,8 @@ import {
   type Diagnostic,
   type SymbolInformation,
   type Range,
-  SymbolKind
+  SymbolKind,
+  type WorkspaceFolder
 } from 'vscode-languageserver'
 import type Parser from 'web-tree-sitter'
 import { TextDocument } from 'vscode-languageserver-textdocument'
@@ -34,13 +35,13 @@ interface AnalyzedDocument {
   embeddedRegions: EmbeddedRegions
   tree: Parser.Tree
   extraSymbols?: GlobalDeclarations[] // symbols from the include files
-  symbolsInStringContent?: SymbolInformation[]
 }
 
 export default class Analyzer {
   private parser?: Parser
   private uriToAnalyzedDocument: Record<string, AnalyzedDocument | undefined> = {}
   private debouncedExecuteAnalyzation?: ReturnType<typeof debounce>
+  public workspaceFolders: WorkspaceFolder[] | undefined | null = []
 
   public getDocumentTexts (uri: string): string[] | undefined {
     return this.uriToAnalyzedDocument[uri]?.document.getText().split(/\r?\n/g)
@@ -74,7 +75,6 @@ export default class Analyzer {
 
     const tree = this.parser.parse(fileContent)
     const globalDeclarations = getGlobalDeclarations({ tree, uri })
-    const symbolsInStringContent = this.getSymbolsInStringContent(tree, uri)
     const embeddedRegions = getEmbeddedRegionsFromNode(tree, uri)
     /* eslint-disable-next-line prefer-const */
     let extraSymbols: GlobalDeclarations[] = []
@@ -85,8 +85,7 @@ export default class Analyzer {
       globalDeclarations,
       embeddedRegions,
       tree,
-      extraSymbols,
-      symbolsInStringContent
+      extraSymbols
     }
 
     let debouncedExecuteAnalyzation = this.debouncedExecuteAnalyzation
@@ -516,85 +515,84 @@ export default class Analyzer {
   /**
    * Extract symbols from the string content of the tree
    */
-  public getSymbolsInStringContent (tree: Parser.Tree, uri: string): SymbolInformation[] {
-    const symbolInformation: SymbolInformation[] = []
-    const wholeWordRegex = /(?<![-.:])\b(\w+)\b(?![-.:])/g
-    TreeSitterUtils.forEach(tree.rootNode, (n) => {
-      if (n.type === 'string_content') {
-        const splittedStringContent = n.text.split(/\n/g)
-        for (let i = 0; i < splittedStringContent.length; i++) {
-          const line = splittedStringContent[i]
-          for (const match of line.matchAll(wholeWordRegex)) {
-            if (match !== undefined && uri !== undefined) {
-              const start = {
-                line: n.startPosition.row + i,
-                character: match.index !== undefined ? match.index + n.startPosition.column : 0
-              }
-              const end = {
-                line: n.startPosition.row + i,
-                character: match.index !== undefined ? match.index + n.startPosition.column + match[0].length : 0
-              }
-              if (i > 0) {
-                start.character = match.index ?? 0
-                end.character = (match.index ?? 0) + match[0].length
+  public getSymbolsInStringContent (uri: string, line: number, character: number, regex: RegExp): SymbolInformation[] {
+    const allSymbolsAtPosition: SymbolInformation[] = []
+    const n = this.nodeAtPoint(uri, line, character)
+    if (n?.type === 'string_content') {
+      const splittedStringContent = n.text.split(/\n/g)
+      for (let i = 0; i < splittedStringContent.length; i++) {
+        const lineText = splittedStringContent[i]
+        for (const match of lineText.matchAll(regex)) {
+          const matchedUri = match.groups?.uri
+          const start = {
+            line: n.startPosition.row + i,
+            character: match.index !== undefined ? match.index + n.startPosition.column : 0
+          }
+          const end = {
+            line: n.startPosition.row + i,
+            character: match.index !== undefined ? match.index + n.startPosition.column + match[0].length : 0
+          }
+          if (i > 0) {
+            start.character = match.index ?? 0
+            end.character = (match.index ?? 0) + match[0].length
+          }
+          if (this.positionIsInRange(line, character, { start, end })) {
+            if (matchedUri !== undefined) {
+              return [{
+                name: matchedUri,
+                kind: SymbolKind.String,
+                location: {
+                  range: {
+                    start,
+                    end
+                  },
+                  uri
+                }
+              }]
+            }
+            const foundRecipe = bitBakeProjectScannerClient.bitbakeScanResult._recipes.find((recipe) => {
+              return recipe.name === match[0]
+            })
+            if (foundRecipe !== undefined) {
+              if (foundRecipe?.path !== undefined) {
+                allSymbolsAtPosition.push({
+                  name: match[0],
+                  kind: SymbolKind.Variable,
+                  location: {
+                    range: {
+                      start,
+                      end
+                    },
+                    uri: 'file://' + foundRecipe.path.dir + '/' + foundRecipe.path.base
+                  }
+                })
               }
-              const foundRecipe = bitBakeProjectScannerClient.bitbakeScanResult._recipes.find((recipe) => {
-                return recipe.name === match[0]
-              })
-              if (foundRecipe !== undefined) {
-                if (foundRecipe?.path !== undefined) {
-                  symbolInformation.push({
-                    name: match[0],
+              if (foundRecipe?.appends !== undefined && foundRecipe.appends.length > 0) {
+                foundRecipe.appends.forEach((append) => {
+                  allSymbolsAtPosition.push({
+                    name: append.name,
                     kind: SymbolKind.Variable,
                     location: {
                       range: {
                         start,
                         end
                       },
-                      uri: 'file://' + foundRecipe.path.dir + '/' + foundRecipe.path.base
+                      uri: 'file://' + append.dir + '/' + append.base
                     }
                   })
-                }
-                if (foundRecipe?.appends !== undefined && foundRecipe.appends.length > 0) {
-                  foundRecipe.appends.forEach((append) => {
-                    symbolInformation.push({
-                      name: append.name,
-                      kind: SymbolKind.Variable,
-                      location: {
-                        range: {
-                          start,
-                          end
-                        },
-                        uri: 'file://' + append.dir + '/' + append.base
-                      }
-                    })
-                  })
-                }
+                })
               }
             }
           }
         }
       }
-      return true
-    })
+    }
 
-    return symbolInformation
+    return allSymbolsAtPosition
   }
 
-  public getSymbolInStringContentForPosition (uri: string, line: number, column: number): SymbolInformation[] | undefined {
-    const analyzedDocument = this.uriToAnalyzedDocument[uri]
-    if (analyzedDocument?.symbolsInStringContent !== undefined) {
-      const { symbolsInStringContent } = analyzedDocument
-      const allSymbolsFoundAtPosition: SymbolInformation[] = [] // recipe + appends
-      for (const symbol of symbolsInStringContent) {
-        const { location: { range } } = symbol
-        if (line === range.start.line && column >= range.start.character && column <= range.end.character) {
-          allSymbolsFoundAtPosition.push(symbol)
-        }
-      }
-      return allSymbolsFoundAtPosition
-    }
-    return undefined
+  public positionIsInRange (line: number, character: number, range: Range): boolean {
+    return line === range.start.line && character >= range.start.character && character <= range.end.character
   }
 }