feat: LG template go to definition in language server

Composer/packages/lib/code-editor/src/lg/LgCodeEditor.tsx

@@ -4,6 +4,7 @@
 import styled from '@emotion/styled';
 import { EditorDidMount } from '@monaco-editor/react';
 import { FluentTheme, NeutralColors } from '@uifabric/fluent-theme';
+import { navigate } from '@reach/router';
 import formatMessage from 'format-message';
 import get from 'lodash/get';
 import { MonacoLanguageClient, MonacoServices } from 'monaco-languageclient';
@@ -81,6 +82,7 @@ export const LgCodeEditor = (props: LgCodeEditorProps) => {
     quickSuggestions: true,
     wordBasedSuggestions: false,
     folding: true,
+    definitions: true,
     ...props.options,
   };
 
@@ -130,6 +132,14 @@ export const LgCodeEditor = (props: LgCodeEditorProps) => {
           const disposable = languageClient.start();
           connection.onClose(() => disposable.dispose());
           window.monacoLGEditorInstance = languageClient;
+
+          languageClient.onReady().then(() =>
+            languageClient.onNotification('GotoDefinition', (result) => {
+              if (lgOption?.projectId) {
+                navigate(`/bot/${lgOption.projectId}/language-generation/${result.fileId}/edit#L=${result.line}`);
+              }
+            })
+          );
         },
       });
     } else {

Composer/packages/tools/language-servers/language-generation/src/LGServer.ts

@@ -19,6 +19,7 @@ import {
   DocumentOnTypeFormattingParams,
   FoldingRangeParams,
   FoldingRange,
+  Location,
 } from 'vscode-languageserver-protocol';
 import get from 'lodash/get';
 import isEqual from 'lodash/isEqual';
@@ -55,6 +56,8 @@ export class LGServer {
   private _lgParser = new LgParser();
   private _luisEntities: string[] = [];
   private _lastLuContent: string[] = [];
+  private _lgFile: LgFile | undefined = undefined;
+  private _templateDefinitions: Record<string, any> = {};
   constructor(
     protected readonly connection: IConnection,
     protected readonly getLgResources: (projectId?: string) => ResolverResource[],
@@ -86,13 +89,15 @@ export class LGServer {
           },
           hoverProvider: true,
           foldingRangeProvider: true,
+          definitionProvider: true,
           documentOnTypeFormattingProvider: {
             firstTriggerCharacter: '\n',
           },
         },
       };
     });
     this.connection.onCompletion(async (params) => await this.completion(params));
+    this.connection.onDefinition((params: TextDocumentPositionParams) => this.definitionHandler(params));
     this.connection.onHover(async (params) => await this.hover(params));
     this.connection.onDocumentOnTypeFormatting((docTypingParams) => this.docTypeFormat(docTypingParams));
     this.connection.onFoldingRanges((foldingRangeParams: FoldingRangeParams) =>
@@ -126,6 +131,30 @@ export class LGServer {
     this.connection.listen();
   }
 
+  protected definitionHandler(params: TextDocumentPositionParams): Location | undefined {
+    const document = this.documents.get(params.textDocument.uri);
+    if (!document) {
+      return;
+    }
+    const wordRange = getRangeAtPosition(document, params.position);
+    const word = document.getText(wordRange);
+    const curFileResult = this._lgFile?.templates.find((t) => t.name === word);
+
+    if (curFileResult?.range) {
+      return Location.create(
+        params.textDocument.uri,
+        Range.create(curFileResult.range.start.line - 1, 0, curFileResult.range.end.line, 0)
+      );
+    }
+
+    const refResult = this._templateDefinitions[word];
+    if (refResult) {
+      this.connection.sendNotification('GotoDefinition', refResult);
+    }
+
+    return;
+  }
+
   protected foldingRangeHandler(params: FoldingRangeParams): FoldingRange[] {
     const document = this.documents.get(params.textDocument.uri);
     const items: FoldingRange[] = [];
@@ -239,13 +268,15 @@ export class LGServer {
       const content = this.documents.get(uri)?.getText() || '';
       // if inline mode, composite local with server resolved file.
       const lgTextFiles = projectId ? this.getLgResources(projectId) : [];
+      this.recordTemplatesDefintions(lgTextFiles);
       if (fileId && templateId) {
         const lgTextFile = lgTextFiles.find((item) => item.id === fileId);
         if (lgTextFile) {
           const lgFile = await this._lgParser.parse(lgTextFile.id, lgTextFile.content, lgTextFiles);
           return await this._lgParser.updateTemplate(lgFile, templateId, { body: content }, lgTextFiles);
         }
       }
+
       return await this._lgParser.parse(fileId || uri, content, lgTextFiles);
     };
     const lgDocument: LGDocument = {
@@ -258,6 +289,28 @@ export class LGServer {
     this.LGDocuments.push(lgDocument);
   }
 
+  protected async recordTemplatesDefintions(lgTextFiles: any[]) {
+    for (const file of lgTextFiles) {
+      const lgTemplates = await this._lgParser.parse(file.id, file.content, lgTextFiles);
+      for (const template of lgTemplates.templates) {
+        this._templateDefinitions[template.name] = {
+          fileId: this.removeLocaleInId(file.id),
+          templateId: template.name,
+          line: template?.range?.start?.line,
+        };
+      }
+    }
+  }
+
+  private removeLocaleInId(fileId: string): string {
+    const idx = fileId.lastIndexOf('.');
+    if (idx !== -1) {
+      return fileId.substring(0, idx);
+    } else {
+      return fileId;
+    }
+  }
+
   protected getLGDocument(document: TextDocument): LGDocument | undefined {
     return this.LGDocuments.find(({ uri }) => uri === document.uri);
   }
@@ -848,6 +901,7 @@ export class LGServer {
       return;
     }
 
+    this._lgFile = lgFile;
     if (text.length === 0) {
       this.cleanDiagnostics(document);
       return;

Composer/packages/tools/language-servers/language-generation/src/utils.ts

@@ -51,7 +51,7 @@ export function getRangeAtPosition(document: TextDocument, position: Position):
   const pos = position.character;
   const lineText = text.split(/\r?\n/g)[line];
   let match: RegExpMatchArray | null;
-  const wordDefinition = /[a-zA-Z0-9_/.]+/g;
+  const wordDefinition = /[a-zA-Z0-9_]+/g;
   while ((match = wordDefinition.exec(lineText))) {
     const matchIndex = match.index || 0;
     if (matchIndex > pos) {