extend semantic highlight, complete embeded arguments

Author: d-biehl

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
+## added
+
+- extend sematic higlightning
+    - builtin library keywords are declared as default_library modifier
+    - higlight variables in keyword names and keyword calls
+- complete embedded arguments
+
 ##  0.2.9
 
 ### added

robotcode/debugger/__main__.py

@@ -126,8 +126,8 @@ async def run_robot(
 
     from ..utils.debugpy import enable_debugpy, wait_for_debugpy_connected
     from ..utils.net import check_free_port
-    from .debugger import Debugger
     from .dap_types import Event
+    from .debugger import Debugger
 
     @_logger.call
     async def start_debugpy_async() -> None:

robotcode/debugger/client.py

@@ -5,8 +5,8 @@
 
 from ..jsonrpc2.server import TcpParams
 from ..utils.logging import LoggingDescriptor
-from .protocol import DebugAdapterProtocol
 from .dap_types import Event
+from .protocol import DebugAdapterProtocol
 
 
 class DAPClientProtocol(DebugAdapterProtocol):

robotcode/debugger/launcher/server.py

@@ -9,7 +9,6 @@
 from ...jsonrpc2.server import JsonRPCServer, JsonRpcServerMode, TcpParams
 from ...utils.logging import LoggingDescriptor
 from ..client import DAPClient, DAPClientError
-from ..protocol import DebugAdapterProtocol
 from ..dap_types import (
     Capabilities,
     ConfigurationDoneArguments,
@@ -31,6 +30,7 @@
     TerminatedEvent,
     TerminateRequest,
 )
+from ..protocol import DebugAdapterProtocol
 
 
 class OutputProtocol(asyncio.SubprocessProtocol):

robotcode/debugger/listeners.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, Iterator, List, Optional, Union, cast
 
-from .debugger import Debugger
 from .dap_types import Event, Model
+from .debugger import Debugger
 
 
 class RobotExecutionEvent(Model):

robotcode/debugger/server.py

@@ -5,8 +5,6 @@
 from ..jsonrpc2.protocol import rpc_method
 from ..jsonrpc2.server import JsonRPCServer, JsonRpcServerMode, TcpParams
 from ..utils.logging import LoggingDescriptor
-from .debugger import Debugger
-from .protocol import DebugAdapterProtocol
 from .dap_types import (
     ConfigurationDoneArguments,
     ContinueArguments,
@@ -40,6 +38,8 @@
     VariablesArguments,
     VariablesResponseBody,
 )
+from .debugger import Debugger
+from .protocol import DebugAdapterProtocol
 
 TCP_DEFAULT_PORT = 6612
 

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -130,6 +130,10 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}(name={repr(self.name)})"
 
 
+class InvalidVariableError(Exception):
+    pass
+
+
 class VariableMatcher:
     def __init__(self, name: str) -> None:
         from robot.utils.normalizing import normalize
@@ -138,6 +142,9 @@ def __init__(self, name: str) -> None:
         searcher = VariableSearcher("$@&%", ignore_errors=True)
         match = searcher.search(name)
         self.name = name
+        if match.base is None:
+            raise InvalidVariableError(f"Invalid variable '{name}'")
+
         self.base = match.base
         self.normalized_name = str(normalize(match.base, "_"))
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -2,6 +2,7 @@
 
 import ast
 import asyncio
+import itertools
 import weakref
 from collections import OrderedDict
 from dataclasses import dataclass, field
@@ -20,7 +21,6 @@
     Tuple,
     cast,
 )
-import itertools
 
 from ....utils.async_itertools import async_chain
 from ....utils.logging import LoggingDescriptor
@@ -35,7 +35,12 @@
     Position,
     Range,
 )
-from ..utils.ast import Token, is_non_variable_token, range_from_token_or_node
+from ..utils.ast import (
+    Token,
+    is_non_variable_token,
+    range_from_token_or_node,
+    tokenize_variables,
+)
 from ..utils.async_ast import AsyncVisitor
 from .imports_manager import ImportsManager
 from .library_doc import (
@@ -220,6 +225,46 @@ async def get(self, source: str, model: ast.AST) -> List[VariableDefinition]:
         await self.visit(model)
         return self._results
 
+    async def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
+        from robot.parsing.lexer.tokens import Token as RobotToken
+        from robot.parsing.model.statements import KeywordName
+        from robot.variables.search import VariableSearcher
+
+        n = cast(KeywordName, node)
+        name_token = cast(Token, n.get_token(RobotToken.KEYWORD_NAME))
+
+        if name_token is not None and name_token.value:
+            for a in filter(
+                lambda e: e.type == RobotToken.VARIABLE,
+                tokenize_variables(name_token, identifiers="$", ignore_errors=True),
+            ):
+                if a.value:
+                    searcher = VariableSearcher("$", ignore_errors=True)
+                    match = searcher.search(a.value)
+                    if match.base is None:
+                        continue
+                    name = f"{match.identifier}{{{match.base.split(':', 1)[0]}}}"
+
+                    self._results.append(
+                        ArgumentDefinition(
+                            name=name,
+                            name_token=a,
+                            line_no=a.lineno,
+                            col_offset=node.col_offset,
+                            end_line_no=node.end_lineno
+                            if node.end_lineno is not None
+                            else a.lineno
+                            if a.lineno is not None
+                            else -1,
+                            end_col_offset=node.end_col_offset
+                            if node.end_col_offset is not None
+                            else a.end_col_offset
+                            if name_token.end_col_offset is not None
+                            else -1,
+                            source=self.source,
+                        )
+                    )
+
     async def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
@@ -781,7 +826,7 @@ def __init__(
         self._libraries: OrderedDict[str, LibraryEntry] = OrderedDict()
         self._resources: OrderedDict[str, ResourceEntry] = OrderedDict()
         self._variables: OrderedDict[str, VariablesEntry] = OrderedDict()
-        self._initialzed = False
+        self._initialized = False
         self._initialize_lock = asyncio.Lock()
         self._analyzed = False
         self._analyze_lock = asyncio.Lock()
@@ -791,6 +836,7 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
 
         self._keywords: Optional[List[KeywordDoc]] = None
+        self._loop = asyncio.get_event_loop()
 
         # TODO: how to get the search order from model
         self.search_order: Tuple[str, ...] = ()
@@ -814,21 +860,21 @@ async def resources_changed(self, sender: Any, params: List[LibraryDoc]) -> None
 
     @_logger.call
     async def get_diagnostisc(self) -> List[Diagnostic]:
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         await self._analyze()
 
         return self._diagnostics
 
     @_logger.call
     async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         return self._libraries
 
     @_logger.call
     async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         return self._resources
 
@@ -856,9 +902,9 @@ async def get_library_doc(self) -> LibraryDoc:
         return self._library_doc
 
     @_logger.call
-    async def _ensure_initialized(self) -> None:
+    async def ensure_initialized(self) -> bool:
         async with self._initialize_lock:
-            if not self._initialzed:
+            if not self._initialized:
                 imports = await self.get_imports()
 
                 if self.document is not None:
@@ -879,7 +925,12 @@ async def _ensure_initialized(self) -> None:
                 await self._import_default_libraries()
                 await self._import_imports(imports, str(Path(self.source).parent), top_level=True)
 
-                self._initialzed = True
+                self._initialized = True
+        return self._initialized
+
+    @property
+    def initialized(self) -> bool:
+        return self._initialized
 
     async def get_imports(self) -> List[Import]:
         if self._imports is None:
@@ -905,7 +956,7 @@ def get_builtin_variables(cls) -> List[BuiltInVariableDefinition]:
     async def get_variables(self, nodes: Optional[List[ast.AST]] = None) -> Dict[VariableMatcher, VariableDefinition]:
         from robot.parsing.model.blocks import Keyword, TestCase
 
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         result: Dict[VariableMatcher, VariableDefinition] = {}
 
@@ -1246,7 +1297,7 @@ async def _get_resource_entry(self, name: str, base_dir: str, sentinel: Any = No
 
     @_logger.call
     async def get_keywords(self) -> List[KeywordDoc]:
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         if self._keywords is None:
             result: Dict[KeywordMatcher, KeywordDoc] = {}
@@ -1296,10 +1347,13 @@ async def _analyze(self) -> None:
                     self._analyzed = True
 
     async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
-        await self._ensure_initialized()
+        await self.ensure_initialized()
 
         return await KeywordFinder(self).find_keyword(name)
 
+    async def find_keyword_threadsafe(self, name: Optional[str]) -> Optional[KeywordDoc]:
+        return await asyncio.wrap_future(asyncio.run_coroutine_threadsafe(self.find_keyword(name), self._loop))
+
 
 class DiagnosticsEntry(NamedTuple):
     message: str