feat(vscode): introduce setting for modifing the diagnostics severity

With these settings, you can override the default configuration for all diagnostic messages. By combining file, block, and line diagnostic modifiers, you can precisely control how specific errors are displayed.

- **`robotcode.analysis.diagnosticModifiers.ignore`**: Suppresses specific diagnostics from being displayed. You can specify one or more error codes, like `MultipleKeywords` or `[multiple-keywords, VariableNotFound]`. Use `*` to ignore all errors and then maybe add specific error codes to other modifiers, such as `information`, to selectively show them.
- **`robotcode.analysis.diagnosticModifiers.error`**: Treats selected diagnostics as errors.
- **`robotcode.analysis.diagnosticModifiers.warning`**: Displays chosen diagnostics as warnings.
- **`robotcode.analysis.diagnosticModifiers.information`**: Shows specified diagnostics as information
- **`robotcode.analysis.diagnosticModifiers.hint`**: Marks selected diagnostics as hints

These settings allow you to tailor the diagnostic outputs to meet the specific needs of your project.

closes #267
closes #297

Author: d-biehl

package.json

@@ -748,6 +748,51 @@
             "markdownDescription": "Specifies a global [search order](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#specifying-explicit-priority-between-libraries-and-resources) for libraries and resources. This is usefull when you have libraries containing keywords with the same name. **RobotCode** is unable to analyze the library search order in a file specified with [`Set Library Search Order`](https://robotframework.org/robotframework/latest/libraries/BuiltIn.html#Set%20Library%20Search%20Order), so you can define a global order here. Just make sure to call the `Set Library Search Order` keyword somewhere in your robot file or internally in your library.",
             "scope": "resource"
           },
+          "robotcode.analysis.diagnosticModifiers.ignore": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specifies the error codes that should be ignored.\n\n**Example:** if you want to ignore all errors with the code `MultipleKeywords` you can add `MultipleKeywords` to the list. \n\n_Note:_ add a `*` to ignore all errors.",
+            "scope": "resource"
+          },
+          "robotcode.analysis.diagnosticModifiers.error": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specifies the error codes that should be treated as error.\n\n**Example:** if you ignore all errors with a `*` in the `ignore` setting, put the code `MultipleKeywords` to enable only `MultipleKeywords` errors.",
+            "scope": "resource"
+          },
+          "robotcode.analysis.diagnosticModifiers.warning": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specifies the error codes that should be a warning.\n\n**Example:** if you want that errors with the code `MultipleKeywords` should be a warning instead you can add `MultipleKeywords` to the list.",
+            "scope": "resource"
+          },
+          "robotcode.analysis.diagnosticModifiers.information": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specify the error codes that should be displayed as information.\n\n**Example**: If you want errors with the code `MultipleKeywords` to be shown as information instead of errors, you can add `MultipleKeywords` to the list.",
+            "scope": "resource"
+          },
+          "robotcode.analysis.diagnosticModifiers.hint": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specify the error codes that should be displayed as hint\n\n**Example**: If you want errors with the code `MultipleKeywords` to be shown as hint instead of errors, you can add `MultipleKeywords` to the list.",
+            "scope": "resource"
+          },
           "robotcode.analysis.findUnusedReferences": {
             "type": "boolean",
             "default": false,
@@ -1599,4 +1644,4 @@
   "workspaces": [
     "docs"
   ]
-}
+}

packages/language_server/src/robotcode/language_server/robotframework/configuration.py

@@ -3,7 +3,12 @@
 
 from robotcode.core.workspace import ConfigBase, config_section
 from robotcode.language_server.common.parts.diagnostics import AnalysisProgressMode, DiagnosticsMode
-from robotcode.robot.diagnostics.workspace_config import AnalysisRobotConfig, CacheConfig, RobotConfig
+from robotcode.robot.diagnostics.workspace_config import (
+    AnalysisDiagnosticModifiersConfig,
+    AnalysisRobotConfig,
+    CacheConfig,
+    RobotConfig,
+)
 
 
 @config_section("robotcode.languageServer")
@@ -68,6 +73,7 @@ class AnalysisConfig(ConfigBase):
     find_unused_references: bool = False
     cache: CacheConfig = field(default_factory=CacheConfig)
     robot: AnalysisRobotConfig = field(default_factory=AnalysisRobotConfig)
+    modifiers: AnalysisDiagnosticModifiersConfig = field(default_factory=AnalysisDiagnosticModifiersConfig)
 
 
 @config_section("robotcode")

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

@@ -2,7 +2,7 @@
 import re as re
 from ast import AST
 from collections import defaultdict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Set, Union
 
 from robot.parsing.lexer.tokens import Token
@@ -12,7 +12,7 @@
 
 from ..utils.visitor import Visitor
 
-ACTIONS = ["ignore", "error", "warn", "information", "hint", "reset"]
+ACTIONS = ["ignore", "error", "warning", "information", "hint", "reset"]
 
 ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
 
@@ -153,8 +153,25 @@ def _handle_comment(self, node: Comment) -> None:
                             self.rules_and_codes.actions[i][code] = action
 
 
+@dataclass
+class DiagnosticModifiersConfig:
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)
+
+
 class DiagnosticsModifier:
-    def __init__(self, model: AST) -> None:
+    def __init__(self, model: AST, config: Optional[DiagnosticModifiersConfig] = None) -> None:
+        self.config = config or DiagnosticModifiersConfig()
+
+        self.config.ignore = [i.translate(_translation_table).lower() for i in self.config.ignore]
+        self.config.error = [i.translate(_translation_table).lower() for i in self.config.error]
+        self.config.warning = [i.translate(_translation_table).lower() for i in self.config.warning]
+        self.config.information = [i.translate(_translation_table).lower() for i in self.config.information]
+        self.config.hint = [i.translate(_translation_table).lower() for i in self.config.hint]
+
         self.model = model
 
     @functools.cached_property
@@ -165,7 +182,7 @@ def rules_and_codes(self) -> RulesAndCodes:
 
     def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
         if diagnostic.code is not None:
-            code = (
+            code = orig_code = (
                 str(diagnostic.code).translate(_translation_table).lower()
                 if diagnostic.code is not None
                 else "unknowncode"
@@ -177,6 +194,7 @@ def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
                 code = "*"
                 lines = self.rules_and_codes.codes.get(code)
 
+            modified = False
             if lines is not None and diagnostic.range.start.line in lines:
                 actions = self.rules_and_codes.actions.get(diagnostic.range.start.line)
                 if actions is not None:
@@ -185,16 +203,42 @@ def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
                         if action == "ignore":
                             return None
                         if action == "reset":
-                            pass  # do nothing
+                            pass
                         elif action == "error":
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.ERROR
-                        elif action == "warn":
+                        elif action == "warning":
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.WARNING
                         elif action == "information":
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.INFORMATION
                         elif action == "hint":
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.HINT
 
+            if not modified:
+                if orig_code in self.config.ignore:
+                    return None
+                if orig_code in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif orig_code in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif orig_code in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif orig_code in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif "*" in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif "*" in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif "*" in self.config.ignore:
+                    return None
+
         return diagnostic
 
     def modify_diagnostics(self, diagnostics: List[Diagnostic]) -> List[Diagnostic]:

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

@@ -26,15 +26,15 @@
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.workspace import Workspace, WorkspaceFolder
-from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticsModifier
+from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticModifiersConfig, DiagnosticsModifier
 
 from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
 from ..utils.stubs import Languages
 from .imports_manager import ImportsManager
 from .library_doc import LibraryDoc
 from .namespace import DocumentType, Namespace
-from .workspace_config import AnalysisRobotConfig, CacheConfig, RobotConfig
+from .workspace_config import AnalysisDiagnosticModifiersConfig, AnalysisRobotConfig, CacheConfig, RobotConfig
 
 
 class UnknownFileTypeError(Exception):
@@ -583,4 +583,14 @@ def get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier
         return document.get_cache(self.__get_diagnostic_modifier)
 
     def __get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
-        return DiagnosticsModifier(self.get_model(document, False))
+        analysis_config = self.workspace.get_configuration(AnalysisDiagnosticModifiersConfig, document.uri)
+        return DiagnosticsModifier(
+            self.get_model(document, False),
+            DiagnosticModifiersConfig(
+                ignore=analysis_config.ignore,
+                error=analysis_config.error,
+                warning=analysis_config.warning,
+                information=analysis_config.information,
+                hint=analysis_config.hint,
+            ),
+        )

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

@@ -55,3 +55,13 @@ class CacheConfig(ConfigBase):
 @dataclass
 class AnalysisRobotConfig(ConfigBase):
     global_library_search_order: List[str] = field(default_factory=list)
+
+
+@config_section("robotcode.analysis.diagnosticModifiers")
+@dataclass
+class AnalysisDiagnosticModifiersConfig(ConfigBase):
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)

tests/robotcode/robot/diagnostics/test_modifiers.py

@@ -5,7 +5,11 @@
 from robot.api import get_model
 
 from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity, Position, Range
-from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticsModifier, DisablersVisitor
+from robotcode.robot.diagnostics.diagnostics_modifier import (
+    DiagnosticModifiersConfig,
+    DiagnosticsModifier,
+    DisablersVisitor,
+)
 
 
 @pytest.mark.parametrize(
@@ -308,3 +312,52 @@ def test_diagnostics_modifier_should_work_on_block_level() -> None:
             severity=DiagnosticSeverity.HINT,
         )
     ]
+
+
+def test_diagnostics_modifier_should_be_configurable() -> None:
+    file = """\
+*** Test Cases ***
+first
+    ## robotcode: ignore[unknown-variable]
+    # 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, DiagnosticModifiersConfig(ignore=["unknown-variable"]))
+
+    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,
+        )
+    ]