fix(langserver): normalize path handling should not fully resolve symlinks

fixes #219

Author: d-biehl

packages/core/src/robotcode/core/uri.py

@@ -7,6 +7,8 @@
 from typing import Any, Iterator, Mapping, Optional, Union, overload
 from urllib import parse
 
+from .utils.path import normalized_path
+
 _IS_WIN = os.name == "nt"
 
 _RE_DRIVE_LETTER_PATH = re.compile(r"^\/[a-zA-Z]:")
@@ -158,6 +160,10 @@ def params(self) -> str:
     def query(self) -> str:
         return self._parts.query
 
+    @property
+    def fragment(self) -> str:
+        return self._parts.fragment
+
     @staticmethod
     def from_path(path: Union[str, Path, os.PathLike[str]]) -> Uri:
         result = Uri(Path(path).as_uri())
@@ -188,6 +194,26 @@ def __iter__(self) -> Iterator[str]:
 
     def normalized(self) -> Uri:
         if self.scheme == "file":
-            return Uri.from_path(self.to_path().resolve())
+            return Uri.from_path(normalized_path(self.to_path()))
 
         return Uri(str(self))
+
+    def change(
+        self,
+        *,
+        scheme: Optional[str] = None,
+        netloc: Optional[str] = None,
+        path: Optional[str] = None,
+        params: Optional[str] = None,
+        query: Optional[str] = None,
+        fragment: Optional[str] = None,
+    ) -> Uri:
+
+        return Uri(
+            scheme=scheme if scheme is not None else self.scheme,
+            netloc=netloc if netloc is not None else self.netloc,
+            path=path if path is not None else self.path,
+            params=params if params is not None else self.params,
+            query=query if query is not None else self.query,
+            fragment=fragment if fragment is not None else self.fragment,
+        )

packages/core/src/robotcode/core/utils/path.py

@@ -1,16 +1,49 @@
-from __future__ import annotations
-
-from os import PathLike
+import os
+import re
 from pathlib import Path
 from typing import Any, Union
 
 
 def path_is_relative_to(
-    path: Union[Path, str, PathLike[Any]],
-    other_path: Union[Path, str, PathLike[Any]],
+    path: Union[Path, str, "os.PathLike[Any]"],
+    other_path: Union[Path, str, "os.PathLike[Any]"],
 ) -> bool:
     try:
         Path(path).relative_to(other_path)
         return True
     except ValueError:
         return False
+
+
+_RE_DRIVE_LETTER_PATH = re.compile(r"^[a-zA-Z]:")
+
+
+def normalized_path(path: Union[Path, str, "os.PathLike[Any]"]) -> Path:
+    p = os.path.normpath(os.path.abspath(path))
+
+    if os.name == "nt" and _RE_DRIVE_LETTER_PATH.match(str(p)):
+        return Path(p[0].upper() + p[1:])
+
+    return Path(p)
+
+
+def normalized_path_full(path: Union[Path, str, "os.PathLike[Any]"]) -> Path:
+    p = normalized_path(path)
+
+    orig_parents = list(reversed(p.parents))
+    orig_parents.append(p)
+
+    parents = []
+    for index, parent in enumerate(orig_parents):
+        if parent.exists():
+            ps = (
+                next((f.name for f in parent.parent.iterdir() if f.samefile(parent)), None)
+                if parent.parent is not None and parent.parent != parent
+                else parent.name or parent.anchor
+            )
+
+            parents.append(ps if ps is not None else parent.name)
+        else:
+            return Path(*parents, *[f.name for f in orig_parents[index:]])
+
+    return Path(*parents)

packages/debugger/src/robotcode/debugger/listeners.py

@@ -6,6 +6,8 @@
 from robot import result, running
 from robot.model import Message
 
+from robotcode.core.utils.path import normalized_path
+
 from .dap_types import Event, Model
 from .debugger import Debugger
 
@@ -18,6 +20,14 @@ class RobotExecutionEventBody(Model):
     failed_keywords: Optional[List[Dict[str, Any]]] = None
 
 
+def source_from_attributes(attributes: Dict[str, Any]) -> str:
+    s = attributes.get("source", "")
+    if s:
+        return str(normalized_path(Path(s)))
+
+    return s or ""
+
+
 class ListenerV2:
     ROBOT_LISTENER_API_VERSION = "2"
 
@@ -32,7 +42,7 @@ def start_suite(self, name: str, attributes: Dict[str, Any]) -> None:
                 event="robotStarted",
                 body=RobotExecutionEventBody(
                     type="suite",
-                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')}",
+                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')}",
                     attributes=dict(attributes),
                 ),
             ),
@@ -54,7 +64,7 @@ def end_suite(self, name: str, attributes: Dict[str, Any]) -> None:
                 body=RobotExecutionEventBody(
                     type="suite",
                     attributes=dict(attributes),
-                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')}",
+                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')}",
                     failed_keywords=self.failed_keywords,
                 ),
             ),
@@ -71,7 +81,7 @@ def start_test(self, name: str, attributes: Dict[str, Any]) -> None:
                 event="robotStarted",
                 body=RobotExecutionEventBody(
                     type="test",
-                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')};"
+                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
                     f"{attributes.get('lineno', 0)}",
                     attributes=dict(attributes),
                 ),
@@ -93,7 +103,7 @@ def end_test(self, name: str, attributes: Dict[str, Any]) -> None:
                 event="robotEnded",
                 body=RobotExecutionEventBody(
                     type="test",
-                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')};"
+                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
                     f"{attributes.get('lineno', 0)}",
                     attributes=dict(attributes),
                     failed_keywords=self.failed_keywords,
@@ -142,9 +152,9 @@ def log_message(self, message: Dict[str, Any]) -> None:
             item_id = next(
                 (
                     (
-                        f"{Path(item.source).resolve() if item.source is not None else ''};{item.longname}"
+                        f"{normalized_path(Path(item.source)) if item.source is not None else ''};{item.longname}"
                         if item.type == "SUITE"
-                        else f"{Path(item.source).resolve() if item.source is not None else ''};"
+                        else f"{normalized_path(Path(item.source)) if item.source is not None else ''};"
                         f"{item.longname};{item.line}"
                     )
                     for item in Debugger.instance().full_stack_frames
@@ -189,9 +199,9 @@ def message(self, message: Dict[str, Any]) -> None:
             item_id = next(
                 (
                     (
-                        f"{Path(item.source).resolve() if item.source is not None else ''};{item.longname}"
+                        f"{normalized_path(Path(item.source)) if item.source is not None else ''};{item.longname}"
                         if item.type == "SUITE"
-                        else f"{Path(item.source).resolve() if item.source is not None else ''};"
+                        else f"{normalized_path(Path(item.source)) if item.source is not None else ''};"
                         f"{item.longname};{item.line}"
                     )
                     for item in Debugger.instance().full_stack_frames
@@ -266,15 +276,15 @@ def enqueue(
             item: Union[running.TestSuite, running.TestCase],
         ) -> Iterator[str]:
             if isinstance(item, running.TestSuite):
-                yield f"{Path(item.source).resolve() if item.source is not None else ''};{item.longname}"
+                yield f"{normalized_path(item.source) if item.source is not None else ''};{item.longname}"
 
                 for s in item.suites:
                     yield from enqueue(s)
                 for s in item.tests:
                     yield from enqueue(s)
                 return
 
-            yield f"{Path(item.source).resolve() if item.source is not None else ''};{item.longname};{item.lineno}"
+            yield (f"{normalized_path(item.source) if item.source is not None else ''};{item.longname};{item.lineno}")
 
         if self._event_sended:
             return

packages/debugger/src/robotcode/debugger/run.py

@@ -208,10 +208,10 @@ async def run_debugger(
             wait_for_debugpy_connected()
 
         args = [
-            "--listener",
-            "robotcode.debugger.listeners.ListenerV2",
             "--listener",
             "robotcode.debugger.listeners.ListenerV3",
+            "--listener",
+            "robotcode.debugger.listeners.ListenerV2",
             *args,
         ]
 

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

@@ -37,7 +37,7 @@
 from robotcode.core.utils.dataclasses import as_json, from_json
 from robotcode.core.utils.glob_path import Pattern, iter_files
 from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.core.utils.path import path_is_relative_to
+from robotcode.core.utils.path import normalized_path, path_is_relative_to
 
 from ..__version__ import __version__
 from ..utils import get_robot_version, get_robot_version_str
@@ -183,7 +183,7 @@ def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeTyp
                         self._lib_doc.module_spec is not None
                         and self._lib_doc.module_spec.submodule_search_locations is not None
                         and any(
-                            path_is_relative_to(path, Path(e).resolve())
+                            path_is_relative_to(path, normalized_path(Path(e)))
                             for e in self._lib_doc.module_spec.submodule_search_locations
                         )
                     )
@@ -197,7 +197,7 @@ def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeTyp
                         self._lib_doc.module_spec is None
                         and not self._lib_doc.source
                         and self._lib_doc.python_path
-                        and any(path_is_relative_to(path, Path(e).resolve()) for e in self._lib_doc.python_path)
+                        and any(path_is_relative_to(path, normalized_path(Path(e))) for e in self._lib_doc.python_path)
                     )
                 ):
                     self._invalidate()
@@ -221,14 +221,14 @@ def _update(self) -> None:
                 self.parent.file_watcher_manager.add_file_watchers(
                     self.parent.did_change_watched_files,
                     [
-                        str(Path(location).resolve().joinpath("**"))
+                        str(normalized_path(Path(location)).joinpath("**"))
                         for location in self._lib_doc.module_spec.submodule_search_locations
                     ],
                 )
             )
 
             if source_or_origin is not None and Path(source_or_origin).parent in [
-                Path(loc).resolve() for loc in self._lib_doc.module_spec.submodule_search_locations
+                normalized_path(Path(loc)) for loc in self._lib_doc.module_spec.submodule_search_locations
             ]:
                 return
 
@@ -307,7 +307,7 @@ def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeTyp
                 path = uri.to_path()
                 if (
                     self._document is not None
-                    and (path.resolve() == self._document.uri.to_path().resolve())
+                    and (normalized_path(path) == normalized_path(self._document.uri.to_path()))
                     or self._document is None
                 ):
                     self._invalidate()
@@ -1457,7 +1457,7 @@ def _get_entry_for_resource_import(
         def _get_document() -> TextDocument:
             self._logger.debug(lambda: f"Load resource {name} from source {source}")
 
-            source_path = Path(source).resolve()
+            source_path = normalized_path(Path(source))
             extension = source_path.suffix
             if extension.lower() not in RESOURCE_EXTENSIONS:
                 raise ImportError(

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

@@ -66,6 +66,7 @@
 from robot.variables.finders import VariableFinder
 from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
+from robotcode.core.utils.path import normalized_path
 from robotcode.robot.diagnostics.entities import (
     ArgumentDefinition,
     ImportedVariableDefinition,
@@ -1490,7 +1491,7 @@ def _get_default_variables() -> Any:
     if __default_variables is None:
         __default_variables = Variables()
         for k, v in {
-            "${TEMPDIR}": str(Path(tempfile.gettempdir()).resolve()),
+            "${TEMPDIR}": str(normalized_path(Path(tempfile.gettempdir()))),
             "${/}": os.sep,
             "${:}": os.pathsep,
             "${\\n}": os.linesep,
@@ -2476,7 +2477,7 @@ def complete_library_import(
             ]
 
         for p in paths:
-            path = p.resolve()
+            path = normalized_path(p)
 
             if path.exists() and path.is_dir():
                 result += [
@@ -2541,9 +2542,9 @@ def complete_resource_import(
     if name is None or name.startswith((".", "/", os.sep)):
         name_path = Path(name if name else base_dir)
         if name_path.is_absolute():
-            path = name_path.resolve()
+            path = normalized_path(name_path)
         else:
-            path = Path(base_dir, name if name else base_dir).resolve()
+            path = normalized_path(Path(base_dir, name if name else base_dir))
 
         if path.exists() and (path.is_dir()):
             result += [
@@ -2592,7 +2593,7 @@ def complete_variables_import(
             ]
 
         for p in paths:
-            path = p.resolve()
+            path = normalized_path(p)
 
             if path.exists() and path.is_dir():
                 result += [

packages/runner/src/robotcode/runner/cli/discover/discover.py

@@ -39,6 +39,7 @@
 from robotcode.core.uri import Uri
 from robotcode.core.utils.cli import show_hidden_arguments
 from robotcode.core.utils.dataclasses import from_json
+from robotcode.core.utils.path import normalized_path
 from robotcode.plugin import (
     Application,
     OutputFormat,
@@ -273,7 +274,7 @@ def visit_suite(self, suite: TestSuite) -> None:
         self._collected[-1][suite.name] = True
         self._collected.append(NormalizedDict(ignore="_"))
         try:
-            absolute_path = Path(suite.source).resolve() if suite.source else None
+            absolute_path = normalized_path(Path(suite.source)) if suite.source else None
             item = TestItem(
                 type="suite",
                 id=f"{absolute_path or ''};{suite.longname}",
@@ -328,7 +329,7 @@ def visit_test(self, test: TestCase) -> None:
         if self._current.children is None:
             self._current.children = []
         try:
-            absolute_path = Path(test.source).resolve() if test.source is not None else None
+            absolute_path = normalized_path(Path(test.source)) if test.source is not None else None
             item = TestItem(
                 type="test",
                 id=f"{absolute_path or ''};{test.longname};{test.lineno}",
@@ -417,7 +418,7 @@ def add_diagnostic(
         line: Optional[int] = None,
         text: Optional[str] = None,
     ) -> None:
-        source_uri = str(Uri.from_path(Path(source_uri).resolve() if source_uri else Path.cwd()))
+        source_uri = str(Uri.from_path(normalized_path(Path(source_uri)) if source_uri else Path.cwd()))
 
         if source_uri not in result:
             result[source_uri] = []