feat(analyze): allow shortforms of warning and information, warn and info in diagnostic modifiers

Author: d-biehl

packages/robot/src/robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -3,6 +3,7 @@
 from ast import AST
 from collections import defaultdict
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import Dict, List, Optional, Set, Union
 
 from robot.parsing.lexer.tokens import Token
@@ -12,23 +13,40 @@
 
 from ..utils.visitor import Visitor
 
-ACTIONS = ["ignore", "error", "warning", "information", "hint", "reset"]
+ACTIONS = ["ignore", "error", "warn", "warning", "info", "information", "hint", "reset"]
 
 ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
 
 
+class ModifierAction(Enum):
+    IGNORE = "ignore"
+    ERROR = "error"
+    WARNING = "warning"
+    INFORMATION = "information"
+    HINT = "hint"
+    RESET = "reset"
+
+    @classmethod
+    def from_str(cls, value: str) -> "ModifierAction":
+        if value == "warn":
+            value = "warning"
+        elif value == "info":
+            value = "information"
+        return cls(value)
+
+
 @dataclass
 class RulesAndCodes:
     codes: Dict[Union[str, int], Set[int]]
-    actions: Dict[int, Dict[Union[str, int], str]]
+    actions: Dict[int, Dict[Union[str, int], ModifierAction]]
 
 
 _translation_table = str.maketrans("", "", "_- ")
 
 ROBOTCODE_MARKER = "robotcode:"
 
 
-class DisablersVisitor(Visitor):
+class ModifiersVisitor(Visitor):
 
     def __init__(self) -> None:
         super().__init__()
@@ -65,16 +83,17 @@ def visit_Statement(self, node: Statement) -> None:  # noqa: N802
         self._handle_statement_comments(node)
         self.generic_visit(node)
 
-    def _parse_robotcode_disabler(self, comment: str) -> Dict[str, List[str]]:
-        result: Dict[str, List[str]] = {}
+    def _parse_robotcode_disabler(self, comment: str) -> Dict[ModifierAction, List[str]]:
+        result: Dict[ModifierAction, List[str]] = {}
 
         comment = comment.strip()
         m = ROBOTCODE_ACTION_AND_CODES_PATTERN.match(comment)
         if m is None:
             return result
 
         for m in ROBOTCODE_ACTION_AND_CODES_PATTERN.finditer(comment):
-            action = m.group("action")
+            action_str = m.group("action")
+            action = ModifierAction.from_str(action_str)
             messages = m.group("codes")
             result[action] = (
                 [m.strip().translate(_translation_table).lower() for m in messages.split(",")]
@@ -176,7 +195,7 @@ def __init__(self, model: AST, config: Optional[DiagnosticModifiersConfig] = Non
 
     @functools.cached_property
     def rules_and_codes(self) -> RulesAndCodes:
-        visitor = DisablersVisitor()
+        visitor = ModifiersVisitor()
         visitor.visit(self.model)
         return visitor.rules_and_codes
 
@@ -200,20 +219,20 @@ def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
                 if actions is not None:
                     action = actions.get(code)
                     if action is not None:
-                        if action == "ignore":
+                        if action == ModifierAction.IGNORE:
                             return None
-                        if action == "reset":
+                        if action == ModifierAction.RESET:
                             pass
-                        elif action == "error":
+                        elif action == ModifierAction.ERROR:
                             modified = True
                             diagnostic.severity = DiagnosticSeverity.ERROR
-                        elif action == "warning":
+                        elif action == ModifierAction.WARNING:
                             modified = True
                             diagnostic.severity = DiagnosticSeverity.WARNING
-                        elif action == "information":
+                        elif action == ModifierAction.INFORMATION:
                             modified = True
                             diagnostic.severity = DiagnosticSeverity.INFORMATION
-                        elif action == "hint":
+                        elif action == ModifierAction.HINT:
                             modified = True
                             diagnostic.severity = DiagnosticSeverity.HINT
 

tests/robotcode/robot/diagnostics/test_modifiers.py

@@ -8,32 +8,36 @@
 from robotcode.robot.diagnostics.diagnostics_modifier import (
     DiagnosticModifiersConfig,
     DiagnosticsModifier,
-    DisablersVisitor,
+    ModifierAction,
+    ModifiersVisitor,
 )
 
 
 @pytest.mark.parametrize(
     ("text", "expected_action_and_codes"),
     [
-        ("ignore", {"ignore": ["*"]}),
-        ("warn", {"warn": ["*"]}),
-        ("error", {"error": ["*"]}),
-        ("hint", {"hint": ["*"]}),
+        ("ignore", {ModifierAction.IGNORE: ["*"]}),
+        ("warn", {ModifierAction.WARNING: ["*"]}),
+        ("warning", {ModifierAction.WARNING: ["*"]}),
+        ("info", {ModifierAction.INFORMATION: ["*"]}),
+        ("information", {ModifierAction.INFORMATION: ["*"]}),
+        ("error", {ModifierAction.ERROR: ["*"]}),
+        ("hint", {ModifierAction.HINT: ["*"]}),
         ("garbage", {}),
-        ("ignore[message]", {"ignore": ["message"]}),
-        ("ignore[message1, message2]", {"ignore": ["message1", "message2"]}),
+        ("ignore[message]", {ModifierAction.IGNORE: ["message"]}),
+        ("ignore[message1, message2]", {ModifierAction.IGNORE: ["message1", "message2"]}),
         (
             "ignore[message1, message2] hint[message3, message4]",
-            {"ignore": ["message1", "message2"], "hint": ["message3", "message4"]},
+            {ModifierAction.IGNORE: ["message1", "message2"], ModifierAction.HINT: ["message3", "message4"]},
         ),
         (
             "  ignore[message1, message2] hint[message3, message4] garbage ",
-            {"ignore": ["message1", "message2"], "hint": ["message3", "message4"]},
+            {ModifierAction.IGNORE: ["message1", "message2"], ModifierAction.HINT: ["message3", "message4"]},
         ),
     ],
 )
-def test_disabler_parser_should_work(text: str, expected_action_and_codes: Dict[str, List[str]]) -> None:
-    visitor = DisablersVisitor()
+def test_disabler_parser_should_work(text: str, expected_action_and_codes: Dict[ModifierAction, List[str]]) -> None:
+    visitor = ModifiersVisitor()
     assert dict(visitor._parse_robotcode_disabler(text)) == expected_action_and_codes
 
 
@@ -49,7 +53,7 @@ def test_find_disablers_at_line_end() -> None:
 """
 
     model = get_model(io.StringIO(file))
-    visitor = DisablersVisitor()
+    visitor = ModifiersVisitor()
     visitor.visit(model)
     assert visitor.rules_and_codes.codes == {
         "*": {2, 3},
@@ -60,14 +64,14 @@ def test_find_disablers_at_line_end() -> None:
         "message4": {6},
     }
     assert visitor.rules_and_codes.actions == {
-        2: {"*": "ignore"},
-        3: {"*": "warn"},
-        5: {"unknownvariable": "ignore"},
+        2: {"*": ModifierAction.IGNORE},
+        3: {"*": ModifierAction.WARNING},
+        5: {"unknownvariable": ModifierAction.IGNORE},
         6: {
-            "message1": "ignore",
-            "message2": "ignore",
-            "message3": "hint",
-            "message4": "hint",
+            "message1": ModifierAction.IGNORE,
+            "message2": ModifierAction.IGNORE,
+            "message3": ModifierAction.HINT,
+            "message4": ModifierAction.HINT,
         },
     }
 
@@ -361,3 +365,53 @@ def test_diagnostics_modifier_should_be_configurable() -> None:
             severity=DiagnosticSeverity.HINT,
         )
     ]
+
+
+def test_diagnostics_modifier_should_work_as_option_in_implicit_comment() -> None:
+    file = """\
+language: en
+robotcode: ignore[unknown-variable]
+*** Test Cases ***
+first
+    # robotcode: ignore[message_1, message_2]  hint[message 3, message 4]
+
+    unknown keyword
+    unknown keyword1
+    log  ${unknown}
+    log  hello
+
+"""
+    model = get_model(io.StringIO(file))
+    modifier = DiagnosticsModifier(model)
+
+    diagnostics = [
+        Diagnostic(
+            range=Range(start=Position(line=5, character=4), end=Position(line=5, character=12)),
+            message="UnknownVariable",
+            code="UnknownVariable",
+            severity=DiagnosticSeverity.INFORMATION,
+        ),
+        Diagnostic(
+            range=Range(start=Position(line=6, character=4), end=Position(line=6, character=12)),
+            message="Message1",
+            code="message1",
+            severity=DiagnosticSeverity.ERROR,
+        ),
+        Diagnostic(
+            range=Range(start=Position(line=6, character=4), end=Position(line=6, character=12)),
+            message="Message3",
+            code="Message3",
+            severity=DiagnosticSeverity.ERROR,
+        ),
+    ]
+
+    result = modifier.modify_diagnostics(diagnostics)
+
+    assert result == [
+        Diagnostic(
+            range=Range(start=Position(line=6, character=4), end=Position(line=6, character=12)),
+            message="Message3",
+            code="Message3",
+            severity=DiagnosticSeverity.HINT,
+        )
+    ]