Merge pull request #10 from lfortran/dylon/preview

Adds hover previews that show symbol definitions

package.json

@@ -92,10 +92,10 @@
     "sinon": "^19.0.2",
     "ts-sinon": "^2.0.2",
     "tsx": "^4.19.2",
-    "typescript": "^4.9.5"
+    "typescript": "^4.9.5",
+    "vsce": "^2.15.0"
   },
   "dependencies": {
-    "tmp": "^0.2.1",
-    "vsce": "^2.15.0"
+    "tmp": "^0.2.1"
   }
 }

server/src/lfortran-language-server.ts

@@ -7,16 +7,17 @@ import {
   CompletionItem,
   CompletionItemKind,
   CompletionList,
-  Position,
   _Connection,
   DefinitionLink,
   DefinitionParams,
   Diagnostic,
   DidChangeConfigurationNotification,
   DidChangeConfigurationParams,
-  DidChangeWatchedFilesParams,
-  DidChangeTextDocumentParams,
+  // DidChangeTextDocumentParams,
+  // DidChangeWatchedFilesParams,
   DocumentSymbolParams,
+  Hover,
+  HoverParams,
   InitializedParams,
   InitializeParams,
   InitializeResult,
@@ -99,6 +100,7 @@ export class LFortranLanguageServer {
         },
         definitionProvider: true,
         documentSymbolProvider: true,
+        hoverProvider: true,
         textDocumentSync: TextDocumentSyncKind.Incremental,
       }
     };
@@ -302,7 +304,6 @@ export class LFortranLanguageServer {
   // }
 
   extractQuery(text: string, line: number, column: number): string | null {
-    let isIdentifiable = this.isIdentifiable;
     let currLine = 0;
     let currCol = 0;
 
@@ -342,7 +343,7 @@ export class LFortranLanguageServer {
     return null;
   }
 
-  async onCompletion(documentPosition: TextDocumentPositionParams): Promise<CompletionItem[] | CompletionList | undefined> {
+  onCompletion(documentPosition: TextDocumentPositionParams): CompletionItem[] | CompletionList | undefined {
     let uri: string = documentPosition.textDocument.uri;
     let document = this.documents.get(uri);
     let dictionary = this.dictionaries.get(uri);
@@ -359,4 +360,28 @@ export class LFortranLanguageServer {
   onCompletionResolve(item: CompletionItem): CompletionItem {
     return item;
   }
+
+  onHover(params: HoverParams): Hover | undefined {
+    let uri: string = params.textDocument.uri;
+    let document = this.documents.get(uri);
+    let dictionary = this.dictionaries.get(uri);
+    if ((document !== undefined) && (dictionary !== undefined)) {
+      let text: string = document.getText();
+      let pos: Position = params.position;
+      let query: string | null = this.extractQuery(text, pos.line, pos.character);
+      if (query !== null) {
+        let completion: CompletionItem | undefined =
+          dictionary.exactLookup(query) as CompletionItem;
+        let definition: string | undefined = completion?.detail;
+        if (definition !== undefined) {
+          return {
+            contents: {
+              language: "fortran",
+              value: definition,
+            },
+          };
+        }
+      }
+    }
+  }
 }

server/src/main.ts

@@ -33,6 +33,7 @@ connection.onDidChangeConfiguration(server.onDidChangeConfiguration.bind(server)
 // connection.onDidChangeWatchedFiles(server.onDidChangeWatchedFiles.bind(server));
 connection.onCompletion(server.onCompletion.bind(server));
 connection.onCompletionResolve(server.onCompletionResolve.bind(server));
+connection.onHover(server.onHover.bind(server));
 
 documents.onDidClose(server.onDidClose.bind(server));
 documents.onDidChangeContent(server.onDidChangeContent.bind(server));

server/src/prefix-trie.ts

@@ -297,6 +297,20 @@ export class PrefixTrie {
     return true;
   }
 
+  exactLookup(term: string): object | string | undefined {
+    term = term.toLowerCase();
+    let curr: PrefixNode | undefined = this.root;
+    for (let i = 0, k = term.length;
+         (i < k) && (curr !== undefined);
+         i++) {
+      let label: string = term[i];
+      curr = curr.transition(label);
+    }
+    if (curr !== undefined) {
+      return curr.value;
+    }
+  }
+
   lookup(term: string): PrefixIterator {
     term = term.toLowerCase();
     let curr: PrefixNode | undefined = this.root;

server/test/spec/lfortran-language-server.spec.ts

@@ -9,8 +9,11 @@ import {
   DiagnosticSeverity,
   DidChangeConfigurationParams,
   DocumentSymbolParams,
+  Hover,
+  HoverParams,
   InitializeParams,
   Location,
+  MarkedString,
   Position,
   Range,
   RemoteWorkspace,
@@ -510,7 +513,7 @@ describe("LFortranLanguageServer", () => {
   });
 
   describe("onCompletion", () => {
-    it("completes queries based on indexed terms", async () => {
+    it("completes queries based on indexed terms", () => {
       let text: string = "def foo; def bar; def baz; def qux; def quo; ba";
       document.getText.returns(text);
 
@@ -581,7 +584,7 @@ describe("LFortranLanguageServer", () => {
       };
 
       let actual: CompletionItem[] | CompletionList =
-        await server.onCompletion(documentPosition);
+        server.onCompletion(documentPosition);
 
       if (!Array.isArray(actual)) {
         actual = (actual as CompletionList).items;
@@ -603,4 +606,82 @@ describe("LFortranLanguageServer", () => {
       assert.deepEqual(actual, expected);
     });
   });
+
+  describe("onHover", () => {
+    it("displays a symbol's definition", async () => {
+      let text: string = "def foo; def bar; def baz; def qux; def quo; ba";
+      document.getText.returns(text);
+
+      let symbols: SymbolInformation[] = [
+        {
+          name: "foo",
+          kind: SymbolKind.Function,
+          location: {
+            uri: uri,
+            range: {
+              start: {
+                line: 0,
+                character: 0,
+              },
+              end: {
+                line: 0,
+                character: 7,
+              },
+            },
+          },
+        },
+        {
+          name: "bar",
+          kind: SymbolKind.Function,
+          location: {
+            uri: uri,
+            range: {
+              start: {
+                line: 0,
+                character: 9,
+              },
+              end: {
+                line: 0,
+                character: 16,
+              },
+            },
+          },
+        },
+        {
+          name: "baz",
+          kind: SymbolKind.Function,
+          location: {
+            uri: uri,
+            range: {
+              start: {
+                line: 0,
+                character: 18,
+              },
+              end: {
+                line: 0,
+                character: 25,
+              },
+            },
+          },
+        },
+      ];
+
+      server.index(uri, symbols);
+
+      let hoverParams: HoverParams = {
+        textDocument: {
+          uri: uri,
+        },
+        position: {
+          line: 0,
+          character: 5,
+        }
+      };
+
+      let response: Hover = server.onHover(hoverParams);
+      let contents: MarkedString = response.contents as MarkedString;
+      assert.equal(contents.language, "fortran");
+      assert.equal(contents.value, "def foo;");
+    });
+  });
 });

server/test/spec/prefix-trie.spec.ts

@@ -402,4 +402,34 @@ describe("PrefixTrie", () => {
       )
     );
   });
+
+  it("can match terms exactly", () => {
+    fc.assert(
+      fc.property(
+        fc.gen(),
+        fc.uniqueArray(fc.string()),
+        fc.string(),
+        (gen, terms: string[], randomQuery: string) => {
+          let dict: PrefixTrie = PrefixTrie.from(terms);
+
+          if (terms.length > 0) {
+            let exactIndex: number = gen(fc.nat, { max: terms.length - 1 });
+            let exactQuery: string = terms[exactIndex];
+            let exactMatch: string = dict.exactLookup(exactQuery) as string;
+            assert.isDefined(exactMatch);
+            assert.equal(exactQuery.toLowerCase(), exactMatch.toLowerCase());
+          }
+
+          if (dict.contains(randomQuery)) {
+            let exactMatch: string | undefined = dict.exactLookup(randomQuery) as string;
+            assert.isDefined(exactMatch);
+            assert.equal(randomQuery.toLowerCase(), exactMatch.toLowerCase());
+          } else {
+            let exactMatch: string | undefined = dict.exactLookup(randomQuery) as string;
+            assert.isUndefined(exactMatch);
+          }
+        }
+      )
+    );
+  });
 });