wip: start implementing multi language support

Author: d-biehl

robotcode/language_server/common/decorators.py

@@ -1,21 +1,21 @@
-from typing import Any, Callable, List, Protocol, TypeVar, Union, runtime_checkable
+from typing import Any, Callable, List, Protocol, Set, TypeVar, Union, runtime_checkable
 
 from .text_document import TextDocument
 
 _F = TypeVar("_F", bound=Callable[..., Any])
 
 
-def language_id(id: str) -> Callable[[_F], _F]:
+def language_id(id: str, *ids: str) -> Callable[[_F], _F]:
     def decorator(func: _F) -> _F:
-        setattr(func, "__language_id__", id)
+        setattr(func, "__language_id__", {id, *ids})
         return func
 
     return decorator
 
 
 @runtime_checkable
 class HasLanguageId(Protocol):
-    __language_id__: str
+    __language_id__: Set[str]
 
 
 def trigger_characters(characters: List[str]) -> Callable[[_F], _F]:
@@ -72,10 +72,13 @@ class HasCodeActionKinds(Protocol):
 
 def language_id_filter(language_id_or_document: Union[str, TextDocument]) -> Callable[[Any], bool]:
     def filter(c: Any) -> bool:
-        return not isinstance(c, HasLanguageId) or c.__language_id__ == (
-            language_id_or_document.language_id
-            if isinstance(language_id_or_document, TextDocument)
-            else language_id_or_document
+        return not isinstance(c, HasLanguageId) or (
+            (
+                language_id_or_document.language_id
+                if isinstance(language_id_or_document, TextDocument)
+                else language_id_or_document
+            )
+            in c.__language_id__
         )
 
     return filter

robotcode/language_server/common/parts/documents.py

@@ -3,6 +3,7 @@
 import asyncio
 import os
 import re
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -119,7 +120,7 @@ async def _file_watcher(self, sender: Any, changes: List[FileEvent]) -> None:
                         loop=self.parent.loop,
                     )
 
-    async def read_document_text(self, uri: Uri, language_id: Union[str, Callable[[Any], bool]]) -> str:
+    async def read_document_text(self, uri: Uri, language_id: Union[str, Callable[[Any], bool], None]) -> str:
         for e in await self.on_read_document_text(
             self, uri, callback_filter=language_id_filter(language_id) if isinstance(language_id, str) else language_id
         ):
@@ -128,9 +129,18 @@ async def read_document_text(self, uri: Uri, language_id: Union[str, Callable[[A
 
         raise FileNotFoundError(str(uri))
 
+    def detect_language_id(self, path_or_uri: Union[str, os.PathLike[Any], Uri]) -> str:
+        path = path_or_uri.to_path() if isinstance(path_or_uri, Uri) else Path(path_or_uri)
+
+        for lang in self.parent.languages:
+            if path.suffix in lang.extensions:
+                return lang.id
+
+        return "unknown"
+
     @_logger.call
     async def get_or_open_document(
-        self, path: Union[str, os.PathLike[Any]], language_id: str, version: Optional[int] = None
+        self, path: Union[str, os.PathLike[Any]], language_id: Optional[str] = None, version: Optional[int] = None
     ) -> TextDocument:
         uri = Uri.from_path(path).normalized()
 
@@ -141,7 +151,7 @@ async def get_or_open_document(
         try:
             return await self.parent.documents.append_document(
                 document_uri=DocumentUri(uri),
-                language_id=language_id,
+                language_id=language_id or self.detect_language_id(path),
                 text=await self.read_document_text(uri, language_id),
                 version=version,
             )

robotcode/language_server/common/parts/inline_value.py

@@ -46,7 +46,8 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             document_filters: DocumentSelector = []
             for e in self.collect:
                 if isinstance(e, HasLanguageId):
-                    document_filters.append(DocumentFilter(language=e.__language_id__))
+                    for lang_id in e.__language_id__:
+                        document_filters.append(DocumentFilter(language=lang_id))
             capabilities.inline_value_provider = InlineValueRegistrationOptions(
                 work_done_progress=True, document_selector=document_filters if document_filters else None
             )

robotcode/language_server/common/parts/workspace.py

@@ -308,21 +308,23 @@ async def _workspace_will_delete_files(self, files: List[FileDelete], *args: Any
     async def _workspace_did_delete_files(self, files: List[FileDelete], *args: Any, **kwargs: Any) -> None:
         await self.did_delete_files(self, list(f.uri for f in files))
 
-    async def get_configuration(self, section: Type[_TConfig], scope_uri: Union[str, Uri, None] = None) -> _TConfig:
+    async def get_configuration(
+        self, section: Type[_TConfig], scope_uri: Union[str, Uri, None] = None, request: bool = True
+    ) -> _TConfig:
         config = await self.get_configuration_raw(
-            section=cast(HasConfigSection, section).__config_section__, scope_uri=scope_uri
+            section=cast(HasConfigSection, section).__config_section__, scope_uri=scope_uri, request=request
         )
 
         return from_dict(config if config is not None else {}, section)
 
     async def get_configuration_raw(
-        self, section: Optional[str], scope_uri: Union[str, Uri, None] = None
+        self, section: Optional[str], scope_uri: Union[str, Uri, None] = None, request: bool = True
     ) -> Optional[Any]:
-
         if (
             self.parent.client_capabilities
             and self.parent.client_capabilities.workspace
             and self.parent.client_capabilities.workspace.configuration
+            and request
         ):
             r = await self.parent.send_request_async(
                 "workspace/configuration",

robotcode/language_server/robotframework/configuration.py

@@ -41,6 +41,7 @@ class RobotConfig(ConfigBase):
     log_level: Optional[str] = None
     mode: Optional[RpaMode] = None
     languages: Optional[List[str]] = None
+    parsers: Optional[List[str]] = None
 
     def get_rpa_mode(self) -> Optional[bool]:
         if self.mode == RpaMode.RPA:

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -500,7 +500,6 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
         self.parent_protocol = parent_protocol
 
         self.folder = folder
-        get_robot_version()
 
         cache_base_path = self.folder.to_path()
         if (
@@ -1339,7 +1338,7 @@ async def _get_document() -> TextDocument:
                     f"Supported extensions are {', '.join(repr(s) for s in RESOURCE_EXTENSIONS)}."
                 )
 
-            return await self.parent_protocol.documents.get_or_open_document(source_path, "robotframework")
+            return await self.parent_protocol.documents.get_or_open_document(source_path)
 
         entry_key = _ResourcesEntryKey(source)
 

robotcode/language_server/robotframework/parts/discovering.py

@@ -251,6 +251,7 @@ async def generate(suite: TestSuite) -> TestItem:
             config = await self.get_config(workspace_folder)
             rpa_mode = config.get_rpa_mode() if config is not None else None
             languages = await self.parent.documents_cache.get_workspace_languages(workspace_folder)
+            parsers = config.parsers if config is not None else None
 
             if paths is None and config is not None:
                 paths = config.paths
@@ -283,7 +284,14 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
 
                 valid_paths = [i for i in normalize_paths(paths)]
 
-                if get_robot_version() >= (6, 0):
+                if get_robot_version() >= (6, 1):
+                    builder = TestSuiteBuilder(
+                        included_suites=suites if suites else None,
+                        rpa=rpa_mode,
+                        lang=languages,
+                        parsers=parsers,
+                    )
+                elif get_robot_version() >= (6, 0):
                     builder = TestSuiteBuilder(
                         included_suites=suites if suites else None,
                         rpa=rpa_mode,
@@ -318,12 +326,15 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
                     )
                 ]
             else:
-                if get_robot_version() >= (6, 0):
+                if get_robot_version() >= (6, 1):
                     builder = TestSuiteBuilder(
                         included_suites=suites if suites else None,
                         rpa=rpa_mode,
                         lang=languages,
+                        parsers=parsers,
                     )
+                elif get_robot_version() >= (6, 0):
+                    builder = TestSuiteBuilder(included_suites=suites if suites else None, rpa=rpa_mode, lang=languages)
                 else:
                     builder = TestSuiteBuilder(included_suites=suites if suites else None, rpa=rpa_mode)
                 return [await generate(builder.build(str(workspace_path)))]

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -131,7 +131,7 @@ async def __get_document_type(self, document: TextDocument) -> DocumentType:
         elif suffix == ".resource":
             return DocumentType.RESOURCE
         else:
-            return DocumentType.GENERAL
+            return DocumentType.UNKNOWN
 
     async def get_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
         if data_only:

robotcode/language_server/robotframework/parts/hover.py

@@ -66,7 +66,11 @@ def _find_method(self, cls: Type[Any]) -> Optional[_HoverMethod]:
     @_logger.call
     async def collect(self, sender: Any, document: TextDocument, position: Position) -> Optional[Hover]:
 
-        result_nodes = await get_nodes_at_position(await self.parent.documents_cache.get_model(document), position)
+        model = await self.parent.documents_cache.get_model(document)
+        if model is None:
+            return None
+
+        result_nodes = await get_nodes_at_position(model, position)
 
         if not result_nodes:
             return None

robotcode/language_server/robotframework/parts/references.py

@@ -148,12 +148,12 @@ async def _find_references_in_workspace(
 
         # tasks = []
         for doc in self.parent.documents.documents:
-            if doc.language_id == "robotframework":
-                result.extend(await func(doc, *args, **kwargs))
-                if result and stop_at_first:
-                    break
+            # if doc.language_id == "robotframework":
+            result.extend(await func(doc, *args, **kwargs))
+            if result and stop_at_first:
+                break
 
-                # tasks.append(run_coroutine_in_thread(func, doc, *args, **kwargs))
+            # tasks.append(run_coroutine_in_thread(func, doc, *args, **kwargs))
 
         # result = await asyncio.gather(*tasks)