fix(analyze): tighten path filtering and refine code output

- Path arguments to `robotcode analyze code` are now matched segment-wise:
  passing `tests/api` no longer pulls in siblings like `tests/api_v2`.
- Workspace-level diagnostics (e.g. variable/library import errors) are
  now prefixed with `.:` instead of being printed without any source
  marker; their related-information lines keep their line/column.
- The summary line picks its color from the highest severity present
  (red/yellow/blue/cyan) instead of only highlighting errors.
- Unused-keyword/variable collectors are only registered when
  `--collect-unused` is set, and empty document reports from the
  analysis pass are no longer emitted.

Author: d-biehl

packages/analyze/src/robotcode/analyze/code/cli.py

@@ -158,7 +158,7 @@ def _validate_load_library_timeout(ctx: click.Context, param: click.Option, valu
 @click.option(
     "-f",
     "--filter",
-    "filter",
+    "filter_patterns",
     metavar="PATTERN",
     type=str,
     multiple=True,
@@ -279,7 +279,7 @@ def _validate_load_library_timeout(ctx: click.Context, param: click.Option, valu
 @pass_application
 def code(
     app: Application,
-    filter: Tuple[str, ...],
+    filter_patterns: Tuple[str, ...],
     variable: Tuple[str, ...],
     variablefile: Tuple[str, ...],
     pythonpath: Tuple[str, ...],
@@ -290,7 +290,7 @@ def code(
     modifiers_hint: Tuple[str, ...],
     exit_code_mask: ExitCodeMask,
     extend_exit_code_mask: ExitCodeMask,
-    paths: Tuple[Path],
+    paths: Tuple[Path, ...],
     load_library_timeout: Optional[int],
     collect_unused: Optional[bool],
     cache_namespaces: Optional[bool],
@@ -425,25 +425,31 @@ def code(
             ),
         )
         try:
-            for e in analyzer.run(paths=paths, filter=filter):
+            for e in analyzer.run(paths=paths, filter_patterns=filter_patterns):
                 result_collector.add_diagnostics_report(e)
 
             for e in result_collector.diagnostics:
                 if isinstance(e, FolderDiagnosticReport):
                     if e.items:
-                        _print_diagnostics(app, root_folder, e.items, e.folder.uri.to_path())
+                        folder_path = try_get_relative_path(e.folder.uri.to_path(), root_folder)
+                        _print_diagnostics(app, root_folder, e.items, folder_path, print_range=False)
                 elif isinstance(e, DocumentDiagnosticReport):
-                    doc_path = (
-                        e.document.uri.to_path().relative_to(root_folder) if root_folder else e.document.uri.to_path()
-                    )
+                    doc_path = try_get_relative_path(e.document.uri.to_path(), root_folder)
                     if e.items:
                         _print_diagnostics(app, root_folder, e.items, doc_path)
         finally:
             result_collector.stop()
 
         statistics_str = str(result_collector)
-        if result_collector.errors > 0:
-            statistics_str = click.style(statistics_str, fg="red")
+        for count, severity in (
+            (result_collector.errors, DiagnosticSeverity.ERROR),
+            (result_collector.warnings, DiagnosticSeverity.WARNING),
+            (result_collector.infos, DiagnosticSeverity.INFORMATION),
+            (result_collector.hints, DiagnosticSeverity.HINT),
+        ):
+            if count > 0:
+                statistics_str = click.style(statistics_str, fg=SEVERITY_COLORS[severity])
+                break
 
         app.echo(statistics_str)
 
@@ -469,7 +475,7 @@ def _print_diagnostics(
                     f"{folder_path}:"
                     + (f"{item.range.start.line + 1}:{item.range.start.character + 1}: " if print_range else " ")
                 )
-                if folder_path and folder_path != root_folder
+                if folder_path
                 else ""
             )
             + click.style(f"[{severity.name[0]}] {item.code}", fg=SEVERITY_COLORS[severity])
@@ -482,10 +488,6 @@ def _print_diagnostics(
 
                 app.echo(
                     f"    {related_path}:"
-                    + (
-                        f"{related.location.range.start.line + 1}:{related.location.range.start.character + 1}: "
-                        if print_range
-                        else " "
-                    )
-                    + f"{indent(related.message, prefix='      ').strip()}",
+                    f"{related.location.range.start.line + 1}:{related.location.range.start.character + 1}: "
+                    f"{indent(related.message, prefix='      ').strip()}",
                 )

packages/analyze/src/robotcode/analyze/code/code_analyzer.py

@@ -6,7 +6,7 @@
 from robotcode.core.lsp.types import Diagnostic
 from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
-from robotcode.core.utils.path import normalized_path
+from robotcode.core.utils.path import normalized_path, path_is_relative_to
 from robotcode.core.workspace import Workspace, WorkspaceFolder
 from robotcode.plugin import Application
 from robotcode.robot.config.model import RobotBaseProfile
@@ -85,7 +85,7 @@ def diagnostics(self) -> DiagnosticHandlers:
         return self._dispatcher
 
     def run(
-        self, paths: Iterable[Path] = {}, filter: Iterable[str] = {}
+        self, paths: Iterable[Path] = (), filter_patterns: Iterable[str] = ()
     ) -> Iterable[Union[DocumentDiagnosticReport, FolderDiagnosticReport]]:
         for folder in self.workspace.workspace_folders:
             self.app.verbose(f"Initialize folder {folder.uri.to_path()}")
@@ -102,7 +102,7 @@ def run(
 
                 yield FolderDiagnosticReport(folder, diagnostics)
 
-            documents = self.collect_documents(folder, paths=paths, filter=filter)
+            documents = self.collect_documents(folder, paths=paths, filter_patterns=filter_patterns)
 
             with self.app.progressbar(documents, label="Analyzing Documents") as progressbar:
                 for document in progressbar:
@@ -117,13 +117,14 @@ def run(
                             else:
                                 diagnostics.extend(item)
 
-                        yield DocumentDiagnosticReport(document, diagnostics)
+                        if diagnostics:
+                            yield DocumentDiagnosticReport(document, diagnostics)
 
             with self.app.progressbar(documents, label="Collecting Diagnostics") as progressbar:
                 for document in progressbar:
                     analyze_result = self.diagnostics.collect_diagnostics(document)
+                    diagnostics = []
                     if analyze_result is not None:
-                        diagnostics = []
                         for item in analyze_result:
                             if item is None:
                                 continue
@@ -132,15 +133,16 @@ def run(
                             else:
                                 diagnostics.extend(item)
 
-                        yield DocumentDiagnosticReport(document, diagnostics)
+                    # Always yield, even when empty: the result collector uses this to count analyzed files.
+                    yield DocumentDiagnosticReport(document, diagnostics)
 
     def collect_documents(
-        self, folder: WorkspaceFolder, paths: Iterable[Path] = {}, filter: Iterable[str] = {}
+        self, folder: WorkspaceFolder, paths: Iterable[Path] = (), filter_patterns: Iterable[str] = ()
     ) -> List[TextDocument]:
         folder_root = folder.uri.to_path()
-        full_paths = [normalized_path(p).as_posix() for p in paths]
+        full_paths = [normalized_path(p) for p in paths]
 
-        ignore_spec = IgnoreSpec.from_list(filter, folder_root)
+        ignore_spec = IgnoreSpec.from_list(filter_patterns, folder_root)
 
         documents: List[TextDocument] = []
 
@@ -151,8 +153,8 @@ def collect_documents(
                 file_counter += 1
                 try:
                     document = self.workspace.documents.get_or_open_document(file)
-                    document_path = normalized_path(document.uri.to_path()).as_posix()
-                    if full_paths and not any(document_path.startswith(p) for p in full_paths):
+                    document_path = normalized_path(document.uri.to_path())
+                    if full_paths and not any(path_is_relative_to(document_path, p) for p in full_paths):
                         continue
 
                     if ignore_spec.rules and not ignore_spec.matches(document.uri.to_path()):

packages/analyze/src/robotcode/analyze/code/robot_framework_language_provider.py

@@ -58,8 +58,9 @@ def __init__(self, diagnostics_context: DiagnosticsContext) -> None:
         self.diagnostics_context.diagnostics.folder_analyzers.add(self.analyze_folder)
         self.diagnostics_context.diagnostics.document_analyzers.add(self.analyze_document)
         self.diagnostics_context.diagnostics.document_collectors.add(self.collect_diagnostics)
-        self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_keywords)
-        self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_variables)
+        if self.diagnostics_context.collect_unused:
+            self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_keywords)
+            self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_variables)
 
     def _update_python_path(self) -> None:
         root_path = (
@@ -125,9 +126,6 @@ def collect_diagnostics(self, sender: Any, document: TextDocument) -> Optional[L
         return self._document_cache.get_diagnostic_modifier(document).modify_diagnostics(namespace.diagnostics)
 
     def collect_unused_keywords(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
-        if not self.diagnostics_context.collect_unused:
-            return None
-
         namespace = self._document_cache.get_namespace(document)
 
         project_index = self._document_cache.get_project_index(document)
@@ -150,9 +148,6 @@ def collect_unused_keywords(self, sender: Any, document: TextDocument) -> Option
         return result
 
     def collect_unused_variables(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
-        if not self.diagnostics_context.collect_unused:
-            return None
-
         result: List[Diagnostic] = []
 
         namespace = self._document_cache.get_namespace(document)