enhance diagnostic message naming

Author: d-biehl

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 .types import Event
     from .debugger import Debugger
+    from .types import Event
 
     @_logger.call
     async def start_debugpy_async() -> None:
@@ -271,7 +271,6 @@ def main() -> None:
         description="RobotCode Debugger",
         prog=__package__,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-        usage="%(prog)s [arguments]... -- [<robot arguments>]...",
     )
 
     parser.add_argument("--version", action="store_true", help="shows the version and exits")
@@ -294,9 +293,7 @@ def main() -> None:
         help="timeout to wait for a configuration from client",
     )
     parser.add_argument("--log", action="store_true", help="enable logging")
-    parser.add_argument(
-        "--log-debugger", action="store_true", help="show debugger log messages"
-    )
+    parser.add_argument("--log-debugger", action="store_true", help="show debugger log messages")
     parser.add_argument("-n", "--no-debug", action="store_true", help="disable debugging")
     parser.add_argument("--debug-asyncio", action="store_true", help="enable async io debugging messages")
     parser.add_argument("--log-asyncio", action="store_true", help="show asyncio log messages")
@@ -326,6 +323,8 @@ def main() -> None:
     )
     parser.add_argument("-soe", "--stop-on-entry", action="store_true", help="Stops on entry.")
 
+    parser.add_argument("--", help="RobotFramework arguments. (see robot --help)", dest="robot args", nargs="*")
+
     sys_args = sys.argv[1:]
 
     split_index = sys_args.index("--") if "--" in sys_args else -1

robotcode/debugger/server.py

@@ -5,6 +5,7 @@
 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 .types import (
     ConfigurationDoneArguments,
@@ -39,7 +40,6 @@
     VariablesArguments,
     VariablesResponseBody,
 )
-from .debugger import Debugger
 
 TCP_DEFAULT_PORT = 6612
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -46,7 +46,7 @@
     is_embedded_keyword,
 )
 
-DIAGNOSTICS_SOURCE_NAME = "RobotCode"
+DIAGNOSTICS_SOURCE_NAME = "robotcode.namespace"
 
 
 class DiagnosticsError(Exception):

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -8,7 +8,7 @@
 from ...common.parts.diagnostics import DiagnosticsResult
 from ...common.text_document import TextDocument
 from ...common.types import Diagnostic, DiagnosticSeverity, Position, Range
-from ..utils.ast import range_from_token
+from ..utils.ast import Token, range_from_token
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -22,7 +22,7 @@ class RobotDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
 
-        self.source_name = "robotcode"
+        self.source_name = "robotcode.diagnostics"
 
         parent.diagnostics.collect.add(self.collect_token_errors)
         # parent.diagnostics.collect.add(self.collect_model_errors)
@@ -35,7 +35,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
     async def namespace_invalidated(self, sender: Any, document: TextDocument) -> None:
         await self.parent.diagnostics.start_publish_diagnostics_task(document)
 
-    def _create_error(self, node: ast.AST, msg: str, source: Optional[str] = None) -> Diagnostic:
+    def _create_error_from_node(self, node: ast.AST, msg: str, source: Optional[str] = None) -> Diagnostic:
         return Diagnostic(
             range=Range(
                 start=Position(line=node.lineno - 1, character=node.col_offset),
@@ -47,6 +47,15 @@ def _create_error(self, node: ast.AST, msg: str, source: Optional[str] = None) -
             code="ModelError",
         )
 
+    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.",
+            severity=DiagnosticSeverity.ERROR,
+            source=source if source is not None else self.source_name,
+            code="TokenError",
+        )
+
     @language_id("robotframework")
     @_logger.call
     async def collect_token_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
@@ -57,38 +66,23 @@ async def collect_token_errors(self, sender: Any, document: TextDocument) -> Dia
 
         for token in await self.parent.documents_cache.get_tokens(document):
             if token.type in [Token.ERROR, Token.FATAL_ERROR]:
-                result.append(
-                    Diagnostic(
-                        range=range_from_token(token),
-                        message=token.error if token.error is not None else "Unknown Error.",
-                        severity=DiagnosticSeverity.ERROR,
-                        source="robot",
-                        code="TokenError",
-                    )
-                )
+                result.append(self._create_error_from_token(token))
 
             try:
                 for variable_token in token.tokenize_variables():
                     if variable_token == token:
                         break
 
                     if variable_token.type in [Token.ERROR, Token.FATAL_ERROR]:
-                        result.append(
-                            Diagnostic(
-                                range=range_from_token(variable_token),
-                                message=token.error if token.error is not None else "Unknown Error.",
-                                severity=DiagnosticSeverity.ERROR,
-                                source="robot",
-                                code="TokenError",
-                            )
-                        )
+                        result.append(self._create_error_from_token(variable_token))
+
             except VariableError as e:
                 result.append(
                     Diagnostic(
                         range=range_from_token(token),
                         message=str(e),
                         severity=DiagnosticSeverity.ERROR,
-                        source="robot",
+                        source=self.source_name,
                         code=type(e).__qualname__,
                     )
                 )
@@ -115,11 +109,11 @@ async def find_from(cls, model: ast.AST, parent: RobotDiagnosticsProtocolPart) -
             async def generic_visit(self, node: ast.AST) -> None:
                 error = getattr(node, "error", None)
                 if error is not None:
-                    self.errors.append(self.parent._create_error(node, error, "robot.visitor"))
+                    self.errors.append(self.parent._create_error_from_node(node, error))
                 errors = getattr(node, "errors", None)
                 if errors is not None:
                     for e in errors:
-                        self.errors.append(self.parent._create_error(node, e, "robot.visitor"))
+                        self.errors.append(self.parent._create_error_from_node(node, e))
                 await super().generic_visit(node)
 
         return DiagnosticsResult(
@@ -137,11 +131,11 @@ async def collect_walk_model_errors(self, sender: Any, document: TextDocument) -
         async for node in walk(await self.parent.documents_cache.get_model(document)):
             error = getattr(node, "error", None)
             if error is not None:
-                result.append(self._create_error(node, error))
+                result.append(self._create_error_from_node(node, error))
             errors = getattr(node, "errors", None)
             if errors is not None:
                 for e in errors:
-                    result.append(self._create_error(node, e))
+                    result.append(self._create_error_from_node(node, e))
 
         return DiagnosticsResult(self.collect_walk_model_errors, result)
 

robotcode/language_server/robotframework/parts/discovering.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from pathlib import Path
 from typing import TYPE_CHECKING, Iterator, List, Optional
 
@@ -150,22 +151,25 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
 
     @rpc_method(name="robot/discovering/getTestsFromDocument", param_type=GetTestsParams)
     async def get_tests_from_document(self, text_document: TextDocumentIdentifier, id: Optional[str]) -> List[TestItem]:
-
+        from robot.output.logger import LOGGER
         from robot.running import TestSuite
 
-        model = TestSuite.from_model(await self.parent.documents_cache.get_model(self.get_document(text_document.uri)))
-
-        return [
-            TestItem(
-                type="test",
-                id=f"{id}.{v.longname}" if id else v.longname,
-                label=v.name,
-                uri=str(Uri.from_path(v.source)),
-                range=Range(
-                    start=Position(line=v.lineno - 1, character=0),
-                    end=Position(line=v.lineno - 1, character=0),
-                ),
-                tags=[t for t in v.tags],
+        with LOGGER.cache_only:
+            model = TestSuite.from_model(
+                await self.parent.documents_cache.get_model(self.get_document(text_document.uri))
             )
-            for v in model.tests
-        ]
+
+            return [
+                TestItem(
+                    type="test",
+                    id=f"{id}.{v.longname}" if id else v.longname,
+                    label=v.name,
+                    uri=str(Uri.from_path(v.source)),
+                    range=Range(
+                        start=Position(line=v.lineno - 1, character=0),
+                        end=Position(line=v.lineno - 1, character=0),
+                    ),
+                    tags=[t for t in v.tags],
+                )
+                for v in model.tests
+            ]