refactor(robotlangserver): Better error messages if converting from json to dataclasses

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -910,14 +910,21 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                 meta_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
                 if meta_file.exists():
                     try:
-                        saved_meta = from_json(meta_file.read_text("utf-8"), LibraryMetaData)
-                        if saved_meta == meta:
-                            return from_json(
-                                Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".spec.json")).read_text(
-                                    "utf-8"
-                                ),
-                                LibraryDoc,
-                            )
+                        try:
+                            saved_meta = from_json(meta_file.read_text("utf-8"), LibraryMetaData)
+                            spec_path = None
+                            if saved_meta == meta:
+                                spec_path = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
+                                return from_json(
+                                    spec_path.read_text("utf-8"),
+                                    LibraryDoc,
+                                )
+                        except (SystemExit, KeyboardInterrupt):
+                            raise
+                        except BaseException as e:
+                            raise RuntimeError(
+                                f"Failed to load library meta data for library {name} from {spec_path}"
+                            ) from e
                     except (SystemExit, KeyboardInterrupt):
                         raise
                     except BaseException as e:

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -257,7 +257,7 @@ def __hash__(self) -> int:
 
 @dataclass
 class ArgumentSpec:
-    name: str
+    name: Optional[str]
     type: str
     positional_only: List[str]
     positional_or_named: List[str]
@@ -377,6 +377,17 @@ def name_range(self) -> Range:
         else:
             return Range.invalid()
 
+    @single_call
+    def normalized_tags(self) -> List[str]:
+        return [normalize(tag) for tag in self.tags]
+
+    @single_call
+    def is_private(self) -> bool:
+        if get_robot_version() < (6, 0, 0):
+            return False
+
+        return "robot:private" in self.normalized_tags()
+
     @property
     def range(self) -> Range:
         if self.name_token is not None:

robotcode/utils/dataclasses.py

@@ -150,6 +150,15 @@ def as_json(obj: Any, indent: Optional[bool] = None, compact: Optional[bool] = N
     return json.dumps(obj, default=__default, indent=4 if indent else None, separators=(",", ":") if compact else None)
 
 
+def _from_dict_with_name(
+    name: str, value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None] = None, /, *, strict: bool = False
+) -> _T:
+    try:
+        return from_dict(value, types, strict=strict)
+    except TypeError as e:
+        raise TypeError(f"Can't convert value for '{name}': {e}") from e
+
+
 def from_dict(value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None] = None, /, *, strict: bool = False) -> _T:
     if types is None:
         return cast(_T, value)
@@ -177,7 +186,7 @@ def from_dict(value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None] = N
             or (isinstance(value, Sequence) and args and issubclass(origin or t, Sequence))
         ):
             if isinstance(value, Mapping):
-                return cast(_T, {n: from_dict(v, args[1] if args else None) for n, v in value.items()})
+                return cast(_T, {n: _from_dict_with_name(n, v, args[1] if args else None) for n, v in value.items()})
             elif isinstance(value, Sequence) and args:
                 return cast(_T, (origin or t)(from_dict(v, args) for v in value))  # type: ignore
 
@@ -234,9 +243,13 @@ def from_dict(value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None] = N
             and match_signature is not None
             and match_type_hints is not None
         ):
+
             params: Dict[str, Any] = {
-                k: from_dict(v, match_type_hints[k]) for k, v in match_value.items() if k in match_type_hints
+                k: _from_dict_with_name(k, v, match_type_hints[k])
+                for k, v in match_value.items()
+                if k in match_type_hints
             }
+
             try:
                 return match(**params)
             except TypeError as ex: