some correction for python 3.10, use protocol for node/token errors instead if getattr

Author: d-biehl

pyproject.toml

@@ -29,6 +29,7 @@ Cython = "^0.29.24"
 robotframework-robocop = "^1.7.1"
 robotframework-tidy = "^1.5.1"
 orjson = "^3.6.3"
+types-orjson = "^3.6.0"
 
 
 [tool.poetry-dynamic-versioning]

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -526,15 +526,17 @@ async def get_libdoc_from_model(
         from robot.running.usererrorhandler import UserErrorHandler
         from robot.running.userkeyword import UserLibrary
 
+        from ..utils.ast import HasError, HasErrors
+
         errors: List[Error] = []
 
         async for node in walk(model):
-            error = getattr(node, "error", None)
+            error = node.error if isinstance(node, HasError) else None
             if error is not None:
                 errors.append(Error(message=error, type_name="ModelError", source=source, line_no=node.lineno))
-            node_error = getattr(node, "errors", None)
-            if node_error is not None:
-                for e in node_error:
+            node_errors = node.errors if isinstance(node, HasErrors) else None
+            if node_errors is not None:
+                for e in node_errors:
                     errors.append(Error(message=e, type_name="ModelError", source=source, line_no=node.lineno))
 
         res = ResourceFile(source=source)

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -92,6 +92,7 @@ async def collect_token_errors(self, sender: Any, document: TextDocument) -> Dia
     @language_id("robotframework")
     @_logger.call
     async def collect_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
+        from ..utils.ast import HasError, HasErrors
         from ..utils.async_ast import AsyncVisitor
 
         class Visitor(AsyncVisitor):
@@ -107,10 +108,11 @@ async def find_from(cls, model: ast.AST, parent: RobotDiagnosticsProtocolPart) -
                 return finder.errors
 
             async def generic_visit(self, node: ast.AST) -> None:
-                error = getattr(node, "error", None)
+                error = node.error if isinstance(node, HasError) else None
                 if error is not None:
                     self.errors.append(self.parent._create_error_from_node(node, error))
-                errors = getattr(node, "errors", None)
+                errors = node.errors if isinstance(node, HasErrors) else None
+
                 if errors is not None:
                     for e in errors:
                         self.errors.append(self.parent._create_error_from_node(node, e))
@@ -124,15 +126,16 @@ async def generic_visit(self, node: ast.AST) -> None:
     @language_id("robotframework")
     @_logger.call
     async def collect_walk_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
+        from ..utils.ast import HasError, HasErrors
         from ..utils.async_ast import walk
 
         result: List[Diagnostic] = []
 
         async for node in walk(await self.parent.documents_cache.get_model(document)):
-            error = getattr(node, "error", None)
+            error = node.error if isinstance(node, HasError) else None
             if error is not None:
                 result.append(self._create_error_from_node(node, error))
-            errors = getattr(node, "errors", None)
+            errors = node.errors if isinstance(node, HasErrors) else None
             if errors is not None:
                 for e in errors:
                     result.append(self._create_error_from_node(node, e))

robotcode/language_server/robotframework/utils/ast.py

@@ -62,6 +62,16 @@ class HasTokens(Protocol):
     tokens: Tuple[Token, ...]
 
 
+@runtime_checkable
+class HasError(Protocol):
+    error: Optional[str]
+
+
+@runtime_checkable
+class HasErrors(Protocol):
+    errors: Optional[List[str]]
+
+
 @runtime_checkable
 class Statement(Protocol):
     def get_token(self, type: str) -> Token:

robotcode/language_server/robotframework/utils/async_ast.py

@@ -21,7 +21,7 @@ async def iter_child_nodes(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
     Yield all direct child nodes of *node*, that is, all fields that are nodes
     and all items of fields that are lists of nodes.
     """
-    async for name, field in iter_fields(node):
+    async for _name, field in iter_fields(node):
         if isinstance(field, ast.AST):
             yield field
         elif isinstance(field, list):
@@ -40,6 +40,22 @@ async def walk(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
         yield node
 
 
+async def iter_nodes(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
+    async for _name, value in iter_fields(node):
+        if isinstance(value, list):
+            for item in value:
+                if isinstance(item, ast.AST):
+                    yield item
+                    async for n in iter_nodes(item):
+                        yield n
+
+        elif isinstance(value, ast.AST):
+            yield value
+
+            async for n in iter_nodes(value):
+                yield n
+
+
 class VisitorFinder:
     def _find_visitor(self, cls: Type[Any]) -> Optional[Callable[..., Any]]:
         if cls is ast.AST: