Support symbols in onHover result

Author: skovhus

server/src/__tests__/analyzer.test.ts

@@ -107,8 +107,9 @@ describe('findSymbolCompletions', () => {
     analyzer.analyze('install.sh', FIXTURES.INSTALL)
     analyzer.analyze('sourcing-sh', FIXTURES.SOURCING)
 
-    expect(analyzer.findSymbolsMatchingWord({ word: 'npm_config_logl' }))
-      .toMatchInlineSnapshot(`
+    expect(
+      analyzer.findSymbolsMatchingWord({ word: 'npm_config_logl', exactMatch: false }),
+    ).toMatchInlineSnapshot(`
       Array [
         Object {
           "kind": 13,
@@ -181,13 +182,13 @@ describe('findSymbolCompletions', () => {
       ]
     `)
 
-    expect(analyzer.findSymbolsMatchingWord({ word: 'xxxxxxxx' })).toMatchInlineSnapshot(
-      `Array []`,
-    )
+    expect(
+      analyzer.findSymbolsMatchingWord({ word: 'xxxxxxxx', exactMatch: false }),
+    ).toMatchInlineSnapshot(`Array []`)
 
-    expect(analyzer.findSymbolsMatchingWord({ word: 'BLU' })).toMatchInlineSnapshot(
-      `Array []`,
-    )
+    expect(
+      analyzer.findSymbolsMatchingWord({ word: 'BLU', exactMatch: false }),
+    ).toMatchInlineSnapshot(`Array []`)
   })
 })
 

server/src/analyser.ts

@@ -264,13 +264,20 @@ export default class Analyzer {
   /**
    * Find symbol completions for the given word.
    */
-  public findSymbolsMatchingWord({ word }: { word: string }): LSP.SymbolInformation[] {
+  public findSymbolsMatchingWord({
+    exactMatch,
+    word,
+  }: {
+    exactMatch: boolean
+    word: string
+  }): LSP.SymbolInformation[] {
     const symbols: LSP.SymbolInformation[] = []
 
     Object.keys(this.uriToDeclarations).forEach(uri => {
       const declarationsInFile = this.uriToDeclarations[uri] || {}
       Object.keys(declarationsInFile).map(name => {
-        if (name.startsWith(word)) {
+        const match = exactMatch ? name === word : name.startsWith(word)
+        if (match) {
           declarationsInFile[name].forEach(symbol => symbols.push(symbol))
         }
       })

server/src/server.ts

@@ -179,9 +179,30 @@ export default class BashServer {
         // eslint-disable-next-line no-console
         return { contents: getMarkdownContent(shellDocumentation) }
       }
-    }
+    } else {
+      const symbolDocumentation = deduplicateSymbols({
+        symbols: this.analyzer.findSymbolsMatchingWord({
+          exactMatch: true,
+          word,
+        }),
+        currentUri,
+      })
+        // do not return hover referencing for the current line
+        .filter(symbol => symbol.location.range.start.line !== params.position.line)
+        .map((symbol: LSP.SymbolInformation) =>
+          symbol.location.uri !== currentUri
+            ? `${symbolKindToDescription(symbol.kind)} defined in ${path.relative(
+                currentUri,
+                symbol.location.uri,
+              )}`
+            : `${symbolKindToDescription(symbol.kind)} defined on line ${symbol.location
+                .range.start.line + 1}`,
+        )
 
-    // FIXME: could also be a symbol
+      if (symbolDocumentation.length === 1) {
+        return { contents: symbolDocumentation[0] }
+      }
+    }
 
     return null
   }
@@ -238,6 +259,7 @@ export default class BashServer {
         ? []
         : getCompletionItemsForSymbols({
             symbols: this.analyzer.findSymbolsMatchingWord({
+              exactMatch: false,
               word,
             }),
             currentUri,
@@ -304,42 +326,39 @@ export default class BashServer {
 
     this.connection.console.log(`onCompletionResolve name=${name} type=${type}`)
 
-    const getMarkdownCompletionItem = (doc: string) => ({
-      ...item,
-      // LSP.MarkupContent
-      documentation: {
-        value: ['``` man', doc, '```'].join('\n'),
-        // Passed as markdown for syntax highlighting
-        kind: 'markdown' as const,
-      },
-    })
-
     try {
-      if (type === CompletionItemDataType.Executable) {
-        const doc = await this.executables.documentation(name)
-        return getMarkdownCompletionItem(doc)
-      } else if (type === CompletionItemDataType.Builtin) {
-        const doc = await Builtins.documentation(name)
-        return getMarkdownCompletionItem(doc)
-      } else if (type === CompletionItemDataType.ReservedWord) {
-        const doc = await ReservedWords.documentation(name)
-        return getMarkdownCompletionItem(doc)
-      } else {
-        return item
+      let documentation = null
+
+      if (
+        type === CompletionItemDataType.Executable ||
+        type === CompletionItemDataType.Builtin ||
+        type === CompletionItemDataType.ReservedWord
+      ) {
+        documentation = await getShellDocumentation({ word: name })
       }
+
+      return documentation
+        ? {
+            ...item,
+            documentation: getMarkdownContent(documentation),
+          }
+        : item
     } catch (error) {
       return item
     }
   }
 }
 
-function getCompletionItemsForSymbols({
+/**
+ * Deduplicate symbols by prioritizing the current file.
+ */
+function deduplicateSymbols({
   symbols,
   currentUri,
 }: {
   symbols: LSP.SymbolInformation[]
   currentUri: string
-}): BashCompletionItem[] {
+}) {
   const isCurrentFile = ({ location: { uri } }: LSP.SymbolInformation) =>
     uri === currentUri
 
@@ -349,7 +368,7 @@ function getCompletionItemsForSymbols({
 
   const symbolsOtherFiles = symbols
     .filter(s => !isCurrentFile(s))
-    // Remove identical symbols
+    // Remove identical symbols matching current file
     .filter(
       symbolOtherFiles =>
         !symbolsCurrentFile.some(
@@ -358,24 +377,33 @@ function getCompletionItemsForSymbols({
         ),
     )
 
-  return uniqueBasedOnHash(
-    [...symbolsCurrentFile, ...symbolsOtherFiles],
-    getSymbolId,
-  ).map((symbol: LSP.SymbolInformation) => ({
-    label: symbol.name,
-    kind: symbolKindToCompletionKind(symbol.kind),
-    data: {
-      name: symbol.name,
-      type: CompletionItemDataType.Symbol,
-    },
-    documentation:
-      symbol.location.uri !== currentUri
-        ? `${symbolKindToDescription(symbol.kind)} defined in ${path.relative(
-            currentUri,
-            symbol.location.uri,
-          )}`
-        : undefined,
-  }))
+  return uniqueBasedOnHash([...symbolsCurrentFile, ...symbolsOtherFiles], getSymbolId)
+}
+
+function getCompletionItemsForSymbols({
+  symbols,
+  currentUri,
+}: {
+  symbols: LSP.SymbolInformation[]
+  currentUri: string
+}): BashCompletionItem[] {
+  return deduplicateSymbols({ symbols, currentUri }).map(
+    (symbol: LSP.SymbolInformation) => ({
+      label: symbol.name,
+      kind: symbolKindToCompletionKind(symbol.kind),
+      data: {
+        name: symbol.name,
+        type: CompletionItemDataType.Symbol,
+      },
+      documentation:
+        symbol.location.uri !== currentUri
+          ? `${symbolKindToDescription(symbol.kind)} defined in ${path.relative(
+              currentUri,
+              symbol.location.uri,
+            )}`
+          : undefined,
+    }),
+  )
 }
 
 function symbolKindToCompletionKind(s: LSP.SymbolKind): LSP.CompletionItemKind {
@@ -440,3 +468,9 @@ function symbolKindToDescription(s: LSP.SymbolKind): string {
       return 'Keyword'
   }
 }
+
+const getMarkdownContent = (documentation: string): LSP.MarkupContent => ({
+  value: ['``` man', documentation, '```'].join('\n'),
+  // Passed as markdown for syntax highlighting
+  kind: 'markdown' as const,
+})