KeywordMatchers now initialize lazy, some refactoring

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -68,15 +68,19 @@
 
 RUN_KEYWORDS_NAME = "Run Keywords"
 
-RUN_KEYWORDS = [*RUN_KEYWORD_NAMES, *RUN_KEYWORD_WITH_CONDITION_NAMES, RUN_KEYWORDS_NAME, RUN_KEYWORD_IF_NAME]
+ALL_RUN_KEYWORDS = [*RUN_KEYWORD_NAMES, *RUN_KEYWORD_WITH_CONDITION_NAMES, RUN_KEYWORDS_NAME, RUN_KEYWORD_IF_NAME]
 
 BUILTIN_LIBRARY_NAME = "BuiltIn"
 RESERVED_LIBRARY_NAME = "Reserved"
 DEFAULT_LIBRARIES = (BUILTIN_LIBRARY_NAME, RESERVED_LIBRARY_NAME, "Easter")
 ROBOT_LIBRARY_PACKAGE = "robot.libraries"
 
 ALLOWED_LIBRARY_FILE_EXTENSIONS = [".py"]
-ALLOWED_RESOURCE_FILE_EXTENSIONS = [".robot", ".resource", ".rst", ".rest", ".txt"]
+
+ROBOT_FILE_EXTENSION = ".robot"
+RESOURCE_FILE_EXTENSION = ".resource"
+
+ALLOWED_RESOURCE_FILE_EXTENSIONS = [ROBOT_FILE_EXTENSION, RESOURCE_FILE_EXTENSION]
 
 DEFAULT_DOC_FORMAT = "ROBOT"
 
@@ -96,16 +100,31 @@ def is_embedded_keyword(name: str) -> bool:
 
 class KeywordMatcher:
     def __init__(self, name: str) -> None:
+        self.name = name
+        self._normalized_name: Optional[str] = None
+        self._embedded_arguments: Any = None
+
+    @property
+    def normalized_name(self) -> str:
+        from robot.utils.normalizing import normalize
+
+        if self._normalized_name is None:
+            self._normalized_name = str(normalize(self.name, "_"))
+
+        return self._normalized_name
+
+    @property
+    def embedded_arguments(self) -> Any:
         from robot.errors import VariableError
         from robot.running.arguments.embedded import EmbeddedArguments
-        from robot.utils.normalizing import normalize
 
-        self.name = name
-        self.normalized_name = str(normalize(name, "_"))
-        try:
-            self.embedded_arguments = EmbeddedArguments(name)
-        except VariableError:
-            self.embedded_arguments = ()
+        if self._embedded_arguments is None:
+            try:
+                self._embedded_arguments = EmbeddedArguments(self.name)
+            except VariableError:
+                self._embedded_arguments = ()
+
+        return self._embedded_arguments
 
     def __eq__(self, o: object) -> bool:
         from robot.utils.normalizing import normalize
@@ -131,6 +150,15 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}(name={repr(self.name)})"
 
 
+RUN_KEYWORD_WITH_CONDITION_MATCHERS = [KeywordMatcher(e) for e in RUN_KEYWORD_WITH_CONDITION_NAMES]
+
+RUN_KEYWORD_IF_MATCHER = KeywordMatcher(RUN_KEYWORD_IF_NAME)
+
+RUN_KEYWORDS_MATCHER = KeywordMatcher(RUN_KEYWORDS_NAME)
+
+ALL_RUN_KEYWORDS_MATCHERS = [KeywordMatcher(e) for e in ALL_RUN_KEYWORDS]
+
+
 class InvalidVariableError(Exception):
     pass
 
@@ -315,7 +343,7 @@ def parameter_signature(self) -> str:
         return f"({', '.join(str(a) for a in self.args)})"
 
     def is_any_run_keyword(self) -> bool:
-        return self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORDS
+        return self.libname == BUILTIN_LIBRARY_NAME and self.name in ALL_RUN_KEYWORDS
 
     def is_run_keyword(self) -> bool:
         return self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORD_NAMES

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -51,7 +51,7 @@ def _create_error_from_node(self, node: ast.AST, msg: str, source: Optional[str]
     def _create_error_from_token(self, token: Token, source: Optional[str] = None) -> Diagnostic:
         return Diagnostic(
             range=range_from_token(token),
-            message=token.error if token.error is not None else "Unknown Error.",
+            message=token.error if token.error is not None else "(No Message).",
             severity=DiagnosticSeverity.ERROR,
             source=source if source is not None else self.source_name,
             code="TokenError",

vscode-client/extension.ts

@@ -10,14 +10,16 @@ class TerminalLink extends vscode.TerminalLink {
   }
 }
 
+let languageClientManger: LanguageClientsManager;
+
 export async function activateAsync(context: vscode.ExtensionContext): Promise<void> {
   const outputChannel = vscode.window.createOutputChannel("RobotCode");
 
   outputChannel.appendLine("Activate RobotCode Extension.");
 
   const pythonManager = new PythonManager(context, outputChannel);
 
-  const languageClientManger = new LanguageClientsManager(context, pythonManager, outputChannel);
+  languageClientManger = new LanguageClientsManager(context, pythonManager, outputChannel);
 
   const debugManager = new DebugManager(context, pythonManager, languageClientManger, outputChannel);
 
@@ -65,17 +67,18 @@ export async function activateAsync(context: vscode.ExtensionContext): Promise<v
   await testControllerManger.refresh();
 }
 
-function displayProgress(promise: Promise<unknown>) {
+function displayProgress<R>(promise: Promise<R>): Thenable<R> {
   const progressOptions: vscode.ProgressOptions = {
     location: vscode.ProgressLocation.Window,
     title: "RobotCode extension loading ...",
   };
-  vscode.window.withProgress(progressOptions, () => promise);
+  return vscode.window.withProgress(progressOptions, () => promise);
 }
 
 export async function activate(context: vscode.ExtensionContext): Promise<void> {
-  displayProgress(activateAsync(context));
+  return await displayProgress(activateAsync(context));
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-export async function deactivate(): Promise<void> {}
+export async function deactivate(): Promise<void> {
+  return await languageClientManger.stopAllClients();
+}

vscode-client/languageclientsmanger.ts

@@ -61,15 +61,15 @@ export class LanguageClientsManager {
       for (const client of this.clients.values()) {
         promises.push(client.stop());
       }
+      this.clients.clear();
 
       await Promise.all(promises);
-
-      this.clients.clear();
     });
   }
 
-  async dispose(): Promise<void> {
-    await this.stopAllClients();
+  dispose(): void {
+    this.stopAllClients().then((_) => undefined);
+
     this._disposables.dispose();
   }
 
@@ -195,7 +195,6 @@ export class LanguageClientsManager {
           this.outputChannel.appendLine(
             `client  ${result?.clientOptions.workspaceFolder?.uri ?? "unknown"} error: ${reason}`
           );
-          vscode.window.showErrorMessage(reason.message ?? "Unknown error.");
           return undefined;
         }
       );

vscode-client/testcontrollermanager.ts

@@ -540,7 +540,7 @@ export class TestControllerManager {
 
               if (event.failedKeywords) {
                 for (const keyword of event.failedKeywords) {
-                  const message = new vscode.TestMessage(keyword.message ?? "unknown error");
+                  const message = new vscode.TestMessage(keyword.message ?? "");
 
                   if (keyword.source) {
                     message.location = new vscode.Location(
@@ -559,7 +559,7 @@ export class TestControllerManager {
                 !event.attributes?.message ||
                 !event.failedKeywords?.find((v) => v.message === event.attributes?.message)
               ) {
-                const message = new vscode.TestMessage(event.attributes.message ?? "unknown error");
+                const message = new vscode.TestMessage(event.attributes.message ?? "");
 
                 if (event.attributes.source) {
                   message.location = new vscode.Location(