fix(langserver): cache to_markdown methods

Author: d-biehl

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

@@ -5,13 +5,16 @@
     TYPE_CHECKING,
     Any,
     Callable,
+    Generic,
     List,
     Optional,
     Tuple,
     TypeVar,
     cast,
 )
 
+from typing_extensions import Concatenate, ParamSpec
+
 from robot.parsing.lexer.tokens import Token
 from robotcode.core.lsp.types import Position, Range
 from robotcode.robot.utils.match import normalize
@@ -41,6 +44,39 @@ def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
     return cast(_F, wrapper)
 
 
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class cached_method(Generic[P, R]):  # noqa: N801
+    def __init__(
+        self, func: Optional[Callable[Concatenate[Any, P], R]] = None, *, maxsize: Optional[int] = None
+    ) -> None:
+        self.func: Optional[Callable[Concatenate[Any, P], R]] = func
+        self._maxsize = maxsize
+        self.cache_name: Optional[str] = None
+        if func is not None:
+            functools.update_wrapper(self, func)
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self.cache_name = f"__cached_{owner.__name__}_{name}"
+
+    def __call__(self, func: Callable[Concatenate[Any, P], R]) -> "cached_method[P, R]":
+        self.func = func
+        functools.update_wrapper(self, func)
+        return self
+
+    def __get__(self, instance: Any, owner: Optional[type] = None) -> Callable[P, R]:
+        cached = instance.__dict__.get(self.cache_name, _NOT_SET)
+        if cached is _NOT_SET:
+            assert self.func is not None
+
+            bound_method = self.func.__get__(instance, owner)
+            cached = functools.lru_cache(maxsize=self._maxsize)(bound_method)
+            instance.__dict__[self.cache_name] = cached
+        return cast(Callable[P, R], cached)
+
+
 @dataclass
 class SourceEntity:
     line_no: int

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

@@ -80,6 +80,7 @@
     LibraryArgumentDefinition,
     NativeValue,
     SourceEntity,
+    cached_method,
     single_call,
 )
 
@@ -362,7 +363,8 @@ def __hash__(self) -> int:
             )
         )
 
-    def to_markdown(self, header_level: int = 2) -> str:
+    @cached_method
+    def to_markdown(self, header_level: int = 2, only_doc: bool = False) -> str:
         result = ""
 
         result += f"##{'#' * header_level} {self.name} ({self.type})\n\n"
@@ -378,19 +380,22 @@ def to_markdown(self, header_level: int = 2) -> str:
             else:
                 result += self.doc
 
-        if self.members:
-            result += f"\n\n###{'#' * header_level} Allowed Values:\n\n"
-            result += "- " + "\n- ".join(f"`{m.name}`" for m in self.members)
-
-        if self.items:
-            result += f"\n\n###{'#' * header_level} Dictionary Structure:\n\n"
-            result += "```\n{"
-            result += "\n ".join(f"'{m.key}': <{m.type}> {'# optional' if not m.required else ''}" for m in self.items)
-            result += "\n}\n```"
+        if not only_doc:
+            if self.members:
+                result += f"\n\n###{'#' * header_level} Allowed Values:\n\n"
+                result += "- " + "\n- ".join(f"`{m.name}`" for m in self.members)
+
+            if self.items:
+                result += f"\n\n###{'#' * header_level} Dictionary Structure:\n\n"
+                result += "```\n{"
+                result += "\n ".join(
+                    f"'{m.key}': <{m.type}> {'# optional' if not m.required else ''}" for m in self.items
+                )
+                result += "\n}\n```"
 
-        if self.accepts:
-            result += f"\n\n###{'#' * header_level} Converted Types:\n\n"
-            result += "- " + "\n- ".join(self.accepts)
+            if self.accepts:
+                result += f"\n\n###{'#' * header_level} Converted Types:\n\n"
+                result += "- " + "\n- ".join(self.accepts)
 
         return result
 
@@ -475,6 +480,7 @@ def from_robot(arg: Any) -> ArgumentInfo:
     def __str__(self) -> str:
         return self.signature()
 
+    @cached_method
     def signature(self, add_types: bool = True) -> str:
         prefix = ""
         if self.kind == KeywordArgumentKind.POSITIONAL_ONLY_MARKER:
@@ -721,6 +727,7 @@ def range(self) -> Range:
             ),
         )
 
+    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,
@@ -796,7 +803,7 @@ def escape_pipe(s: str) -> str:
 
                 result += (
                     f"\n| `{prefix}{a.name!s}`"
-                    f'| {": " if a.types else " "}'
+                    f"| {': ' if a.types else ' '}"
                     f"{escaped_pipe.join(f'`{escape_pipe(s)}`' for s in a.types) if a.types else ''} "
                     f"| {'=' if a.default_value is not None else ''} "
                     f"| {f'`{a.default_value!s}`' if a.default_value else ''} |"
@@ -832,6 +839,7 @@ def signature(self) -> str:
             + ")"
         )
 
+    @cached_method
     def parameter_signature(self, full_signatures: Optional[Sequence[int]] = None) -> str:
         return (
             "("
@@ -1094,6 +1102,7 @@ def range(self) -> Range:
             ),
         )
 
+    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,
@@ -1250,6 +1259,7 @@ class VariablesDoc(LibraryDoc):
 
     variables: List[ImportedVariableDefinition] = field(default_factory=list)
 
+    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,