implement changes for RF 5.1 embedded keywords

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -160,7 +160,7 @@ async def visit(self, node: ast.AST) -> None:
             )
 
             if isinstance(node, Statement) and isinstance(node, KeywordCall) and node.keyword:
-                kw_doc = await self.namespace.find_keyword(node.keyword)
+                kw_doc = await self.finder.find_keyword(node.keyword)
                 if kw_doc is not None and kw_doc.longname in ["BuiltIn.Comment"]:
                     severity = DiagnosticSeverity.HINT
 

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -470,7 +470,6 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
         self.parent_protocol.documents.did_change.add(self.resource_document_changed)
         self._command_line_variables: Optional[List[VariableDefinition]] = None
 
-        # self.process_pool = get_process_pool()
         self._python_path: Optional[List[str]] = None
         self._environment: Optional[Mapping[str, str]] = None
 

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -12,7 +12,6 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from types import ModuleType
 from typing import (
     AbstractSet,
     Any,
@@ -23,7 +22,6 @@
     List,
     NamedTuple,
     Optional,
-    Set,
     Tuple,
     Union,
     cast,
@@ -96,17 +94,22 @@ def is_embedded_keyword(name: str) -> bool:
     from robot.running.arguments.embedded import EmbeddedArguments
 
     try:
-        if EmbeddedArguments(name):
-            return True
+        if get_robot_version() >= (5, 1):
+            if EmbeddedArguments.from_name(name):
+                return True
+        else:
+            if EmbeddedArguments(name):
+                return True
     except (VariableError, DataError):
         return True
 
     return False
 
 
 class KeywordMatcher:
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, can_have_embedded: bool = True) -> None:
         self.name = name
+        self._can_have_embedded = can_have_embedded
         self._normalized_name: Optional[str] = None
         self._embedded_arguments: Any = None
 
@@ -124,9 +127,15 @@ def embedded_arguments(self) -> Any:
         from robot.running.arguments.embedded import EmbeddedArguments
 
         if self._embedded_arguments is None:
-            try:
-                self._embedded_arguments = EmbeddedArguments(self.name)
-            except (VariableError, DataError):
+            if self._can_have_embedded:
+                try:
+                    if get_robot_version() >= (5, 1):
+                        self._embedded_arguments = EmbeddedArguments.from_name(self.name)
+                    else:
+                        self._embedded_arguments = EmbeddedArguments(self.name)
+                except (VariableError, DataError):
+                    self._embedded_arguments = ()
+            else:
                 self._embedded_arguments = ()
 
         return self._embedded_arguments
@@ -142,7 +151,10 @@ def __eq__(self, o: Any) -> bool:
             return False
 
         if self.embedded_arguments:
-            return self.embedded_arguments.name.match(o) is not None
+            if get_robot_version() >= (5, 1):
+                return self.embedded_arguments.match(o) is not None
+            else:
+                return self.embedded_arguments.name.match(o) is not None
 
         return self.normalized_name == str(normalize(o))
 
@@ -714,59 +726,13 @@ def update_python_path_and_env(
 ) -> None:
     os.chdir(Path(working_dir))
 
-    # if pythonpath is not None:
-    #     for p in pythonpath:
-    #         absolute_path = str(Path(p).absolute())
-    #         if absolute_path not in sys.path:
-    #             sys.path.insert(0, absolute_path)
-
-    # if environment:
-    #     for k, v in environment.items():
-    #         os.environ[k] = v
-
-
-__PRELOADED_MODULES: Optional[Set[ModuleType]] = None
-
 
 def _update_env(
     working_dir: str = ".", pythonpath: Optional[List[str]] = None, environment: Optional[Dict[str, str]] = None
 ) -> None:
-    # import gc
-
-    # unload_preloaded_modules()
-
-    # file = Path(__file__).resolve()
-    # top = file.parents[3]
-    # for p in filter(lambda v: path_is_relative_to(v, top), sys.path.copy()):
-    #     sys.path.remove(p)
-
-    # importlib.invalidate_caches()
-
-    # gc.collect()
-
     update_python_path_and_env(working_dir, pythonpath, environment)
 
 
-def unload_preloaded_modules() -> None:
-    global __PRELOADED_MODULES
-
-    if __PRELOADED_MODULES is None:
-        try:
-            __import__("robot.libraries.BuiltIn")
-        except ImportError:
-            pass
-
-        __PRELOADED_MODULES = set(sys.modules.values())
-    else:
-        for m in (f for f in set(sys.modules.values()) - __PRELOADED_MODULES if not f.__name__.startswith("robot.")):
-            try:
-                importlib.reload(m)
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException:
-                pass
-
-
 def get_module_spec(module_name: str) -> Optional[ModuleSpec]:
     import importlib.util
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -689,7 +689,8 @@ async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
     async def get_libraries_matchers(self) -> Dict[KeywordMatcher, LibraryEntry]:
         if self._libraries_matchers is None:
             self._libraries_matchers = {
-                KeywordMatcher(v.alias or v.name or v.import_name): v for v in (await self.get_libraries()).values()
+                KeywordMatcher(v.alias or v.name or v.import_name, False): v
+                for v in (await self.get_libraries()).values()
             }
         return self._libraries_matchers
 
@@ -701,7 +702,8 @@ async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
     async def get_resources_matchers(self) -> Dict[KeywordMatcher, ResourceEntry]:
         if self._resources_matchers is None:
             self._resources_matchers = {
-                KeywordMatcher(v.alias or v.name or v.import_name): v for v in (await self.get_resources()).values()
+                KeywordMatcher(v.alias or v.name or v.import_name, False): v
+                for v in (await self.get_resources()).values()
             }
         return self._resources_matchers
 
@@ -1528,11 +1530,11 @@ async def get_finder(self) -> KeywordFinder:
         return self._finder
 
     @_logger.call(condition=lambda self, name: self._finder is not None and name not in self._finder._cache)
-    async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
+    async def find_keyword(self, name: Optional[str], raise_keyword_error: bool = True) -> Optional[KeywordDoc]:
         if self._finder is not None:
-            return await self._finder.find_keyword(name)
+            return await self._finder.find_keyword(name, raise_keyword_error)
 
-        return await (await self.get_finder()).find_keyword(name)
+        return await (await self.get_finder()).find_keyword(name, raise_keyword_error)
 
 
 class DiagnosticsEntry(NamedTuple):
@@ -1556,7 +1558,7 @@ def __init__(self, namespace: Namespace) -> None:
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
 
-    async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
+    async def find_keyword(self, name: Optional[str], raise_keyword_error: bool = False) -> Optional[KeywordDoc]:
         try:
             self.reset_diagnostics()
 
@@ -1566,13 +1568,21 @@ async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
                 self.diagnostics = cached[1]
                 return cached[0]
             else:
-                result = await self._find_keyword(name)
-                if result is None:
-                    self.diagnostics.append(
-                        DiagnosticsEntry(
-                            f"No keyword with name {repr(name)} found.", DiagnosticSeverity.ERROR, "KeywordError"
+                try:
+                    result = await self._find_keyword(name)
+                    if result is None:
+                        self.diagnostics.append(
+                            DiagnosticsEntry(
+                                f"No keyword with name {repr(name)} found.", DiagnosticSeverity.ERROR, "KeywordError"
+                            )
                         )
-                    )
+                except KeywordError as e:
+                    if raise_keyword_error:
+                        raise
+
+                    result = None
+                    self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, "KeywordError"))
+
                 self._cache[name] = (result, self.diagnostics)
 
                 return result

robotcode/language_server/robotframework/parts/codelens.py

@@ -111,10 +111,7 @@ async def resolve(self, sender: Any, code_lens: CodeLens) -> Optional[CodeLens]:
         name = code_lens.data["name"]
         line = code_lens.data["line"]
 
-        if (
-            self.parent.diagnostics.workspace_loaded_event.is_set()
-            and self.parent.diagnostics.in_get_workspace_diagnostics.is_set()
-        ):
+        if self.parent.diagnostics.workspace_loaded_event.is_set():
             kw_doc = await self.get_keyword_definition_at_line(namespace, name, line)
 
             if kw_doc is not None and not kw_doc.is_error_handler:

robotcode/utils/async_cache.py

@@ -48,8 +48,8 @@ async def get(self, func: Callable[..., Awaitable[_T]], *args: Any, **kwargs: An
                 entry.data = await func(*args, **kwargs)
                 entry.has_data = True
 
-                async with self.lock:
-                    if self._order is not None and self.max_items is not None:
+                if self._order is not None and self.max_items is not None:
+                    async with self.lock:
                         self._order.insert(0, key)
 
                         if len(self._order) > self.max_items:

robotcode/utils/async_tools.py

@@ -436,7 +436,7 @@ def check_canceled_sync() -> bool:
     return True
 
 
-__threadpool_executor = ThreadPoolExecutor(thread_name_prefix="sub_asyncio")
+# __threadpool_executor = ThreadPoolExecutor(thread_name_prefix="sub_asyncio")
 
 
 def run_in_thread(func: Callable[..., _T], /, *args: Any, **kwargs: Any) -> asyncio.Future[_T]:
@@ -447,10 +447,20 @@ def run_in_thread(func: Callable[..., _T], /, *args: Any, **kwargs: Any) -> asyn
     ctx = contextvars.copy_context()
     func_call = functools.partial(ctx.run, func, *args, **kwargs)
 
-    return cast(
-        "asyncio.Future[_T]",
-        loop.run_in_executor(__threadpool_executor, cast(Callable[..., _T], func_call)),
-    )
+    # return cast(
+    #     "asyncio.Future[_T]",
+    #     # loop.run_in_executor(__threadpool_executor, cast(Callable[..., _T], func_call)),
+    #     loop.run_in_executor(None, cast(Callable[..., _T], func_call)),
+    # )
+
+    executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="sub_asyncio")
+    try:
+        return cast(
+            "asyncio.Future[_T]",
+            loop.run_in_executor(executor, cast(Callable[..., _T], func_call)),
+        )
+    finally:
+        executor.shutdown(wait=False)
 
 
 def run_coroutine_in_thread(
@@ -525,10 +535,16 @@ def done(task: asyncio.Future[_T]) -> None:
 
 @contextlib.asynccontextmanager
 async def async_lock(lock: threading.RLock) -> AsyncGenerator[None, None]:
+    import time
+
+    start_time = time.monotonic()
     locked = lock.acquire(blocking=False)
     while not locked:
+        if time.monotonic() - start_time >= 10:
+            raise RuntimeError("Timeout waiting for lock")
+
         await asyncio.sleep(0.001)
-        locked = lock.acquire(False)
+        locked = lock.acquire(blocking=False)
     try:
         yield
     finally:
@@ -878,7 +894,16 @@ def create_sub_task(
     ct = get_current_future_info()
 
     if loop is not None:
-        result = loop.create_task(coro, name=name)
+        if loop == asyncio.get_running_loop():
+            result = loop.create_task(coro, name=name)
+        else:
+
+            async def s(
+                lo: asyncio.AbstractEventLoop, c: Coroutine[Any, Any, _T], n: Optional[str]
+            ) -> asyncio.Task[_T]:
+                return create_sub_task(c, name=n, loop=lo)
+
+            return asyncio.run_coroutine_threadsafe(s(loop, coro, name), loop=loop).result()
     else:
         result = asyncio.create_task(coro, name=name)