fix: set env and pythonpath erlier in lifecycle to prevent that sometime analyses fails because of python path is not correct

Author: d-biehl

robotcode/language_server/common/parts/documents.py

@@ -271,6 +271,8 @@ async def _text_document_did_open(self, text_document: TextDocumentItem, *args:
                 text_changed = document.text() != normalized_text
                 if text_changed:
                     document.apply_full_change(text_document.version, normalized_text)
+                else:
+                    document.version = text_document.version
 
             document.opened_in_editor = True
 

robotcode/language_server/common/protocol.py

@@ -12,7 +12,7 @@
     rpc_method,
 )
 from ...jsonrpc2.server import JsonRPCServer
-from ...utils.async_tools import async_event
+from ...utils.async_tools import Event, async_event
 from ...utils.logging import LoggingDescriptor
 from .has_extend_capabilities import HasExtendCapabilities
 from .lsp_types import (
@@ -132,7 +132,7 @@ def __init__(self, server: JsonRPCServer[Any]):
         )
 
         self._trace = TraceValue.OFF
-        self._is_initialized = False
+        self.is_initialized = Event()
 
     @async_event
     async def on_shutdown(sender) -> None:  # pragma: no cover, NOSONAR
@@ -244,11 +244,7 @@ async def on_initialize(sender, initialization_options: Optional[Any] = None) ->
     async def _initialized(self, params: InitializedParams, *args: Any, **kwargs: Any) -> None:
         await self.on_initialized(self)
 
-        self._is_initialized = True
-
-    @property
-    def is_initialized(self) -> bool:
-        return self._is_initialized
+        self.is_initialized.set()
 
     @async_event
     async def on_initialized(sender) -> None:  # pragma: no cover, NOSONAR

robotcode/language_server/robotframework/protocol.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
@@ -73,6 +73,8 @@ def check_robotframework() -> None:
 class Options(Model):
     storage_uri: Optional[str] = None
     global_storage_uri: Optional[str] = None
+    python_path: List[str] = field(default_factory=list)
+    env: Dict[str, str] = field(default_factory=dict)
 
 
 @symbol_information_label("robotframework")
@@ -137,16 +139,31 @@ async def _on_shutdown(self, sender: Any) -> None:
 
     @_logger.call
     async def _on_initialize(self, sender: Any, initialization_options: Optional[Any] = None) -> None:
+        if initialization_options is not None:
+            self.options = from_dict(initialization_options, Options)
+
+        if self.options.env:
+            for k, v in self.options.env.items():
+                os.environ[k] = v
+
+        if self.options.python_path:
+            for folder in self.workspace.workspace_folders:
+                for p in self.options.python_path:
+                    pa = Path(p)
+                    if not pa.is_absolute():
+                        pa = Path(folder.uri.to_path(), pa)
+
+                    absolute_path = str(pa.absolute())
+                    if absolute_path not in sys.path:
+                        sys.path.insert(0, absolute_path)
+
         try:
             check_robotframework()
         except RobotCodeException as e:
             raise JsonRPCErrorException(
                 JsonRPCErrors.INTERNAL_ERROR, f"Can't start language server: {e}", InitializeError(retry=False)
             ) from e
 
-        if initialization_options is not None:
-            self.options = from_dict(initialization_options, Options)
-
         self.workspace.did_change_configuration.add(self._on_did_change_configuration)
 
         self._logger.critical(f"initialized with {repr(self.options)}")

vscode-client/languageclientsmanger.ts

@@ -352,20 +352,16 @@ export class LanguageClientsManager {
         documentSelector:
           // TODO: use SUPPORTED_LANGUAGES here
           vscode.workspace.workspaceFolders?.length === 1
-            ? [
-                { scheme: "file", language: "robotframework" },
-                { scheme: "file", language: "feature" },
-              ]
-            : [
-                { scheme: "file", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
-                { scheme: "file", language: "feature", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
-              ],
-        synchronize: {
-          configurationSection: [CONFIG_SECTION],
-        },
+            ? [{ scheme: "file", language: "robotframework" }]
+            : [{ scheme: "file", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` }],
+        // synchronize: {
+        //   configurationSection: [CONFIG_SECTION],
+        // },
         initializationOptions: {
           storageUri: this.extensionContext?.storageUri?.toString(),
           globalStorageUri: this.extensionContext?.globalStorageUri?.toString(),
+          pythonPath: config.get<string[]>("robot.pythonPath", []),
+          env: config.get<object>("robot.env", []),
         },
         revealOutputChannelOn: RevealOutputChannelOn.Never, // TODO: should we make this configurable?
         initializationFailedHandler: (error: ResponseError<InitializeError> | Error | undefined) => {