Final review feedback

Author: VeaaC

flatdata-generator/flatdata/generator/tree/nodes/archive.py

@@ -52,5 +52,6 @@ def resources(self) -> list[resources.ResourceBase]:
         return self.children_like(resources.ResourceBase)  # type: ignore[type-abstract]  # isinstance() with ABC is valid
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""

flatdata-generator/flatdata/generator/tree/nodes/resources/base.py

@@ -28,8 +28,9 @@ def optional(self) -> bool:
         return any(['optional' in d for d in self.decorations])
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""
 
     @property
     def decorations(self) -> list[Any]:
@@ -40,8 +41,11 @@ def explicit_references(self) -> list[ExplicitReference]:
         return self.children_like(ExplicitReference)
 
     @property
-    def referenced_structures(self) -> list[Any]:
-        return self.children_like(BuiltinStructureReference) + self.children_like(StructureReference)
+    def referenced_structures(self) -> list[BuiltinStructureReference | StructureReference]:
+        return [
+            *self.children_like(BuiltinStructureReference),
+            *self.children_like(StructureReference),
+        ]
 
     @property
     def max_size(self) -> int | None:

flatdata-generator/flatdata/generator/tree/nodes/resources/bound_resource.py

@@ -1,5 +1,5 @@
 from flatdata.generator.tree.nodes.node import Node
-from flatdata.generator.tree.nodes.references import ResourceReference
+from flatdata.generator.tree.nodes.references import BuiltinStructureReference, ResourceReference, StructureReference
 from .base import ResourceBase
 
 from typing import Any
@@ -21,6 +21,6 @@ def create_references(self) -> list[Node]:
         return [ResourceReference(name=r) for r in self._resources]
 
     @property
-    def referenced_structures(self) -> list[Any]:
+    def referenced_structures(self) -> list[BuiltinStructureReference | StructureReference]:
         return [s for r in self.children_like(ResourceReference) for s in
                 r.node.referenced_structures]  # type: ignore[attr-defined]  # .node resolves to a resource type with referenced_structures

flatdata-generator/flatdata/generator/tree/nodes/trivial/constant.py

@@ -23,8 +23,9 @@ def type(self) -> BasicType:
         return BasicType(self._properties.type)
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""
 
     @property
     def value(self) -> int:

flatdata-generator/flatdata/generator/tree/nodes/trivial/enumeration.py

@@ -47,13 +47,12 @@ def create(properties: Any, definition: Any) -> 'Enumeration':
             bits_required = result._type.bits_required(value=value)
             if bits_required > result._type.width:
                 raise InvalidEnumValueError(enumeration_name=result._name, value=value)
-        result._bits_required = bits_required  # type: ignore[attr-defined]  # dead code: attribute is set but never read anywhere
-
         return result
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""
 
     @property
     def type(self) -> BasicType | None:

flatdata-generator/flatdata/generator/tree/nodes/trivial/enumeration_value.py

@@ -15,8 +15,9 @@ def create(properties: Any, value: int) -> 'EnumerationValue':
         return result
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""
 
     @property
     def value(self) -> int:

flatdata-generator/flatdata/generator/tree/nodes/trivial/field.py

@@ -82,5 +82,6 @@ def offset(self, value: int) -> None:
         self._offset = value
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""

flatdata-generator/flatdata/generator/tree/nodes/trivial/structure.py

@@ -28,8 +28,9 @@ def has_range(self) -> bool:
         return any(f for f in self.fields if f.range)
 
     @property
-    def doc(self) -> Any:
-        return self._properties.doc
+    def doc(self) -> str:
+        doc = self._properties.doc
+        return str(doc) if doc is not None else ""
 
     @property
     def size_in_bits(self) -> int:

flatdata-generator/flatdata/generator/tree/traversal.py

@@ -1,15 +1,28 @@
 from abc import ABCMeta, abstractmethod
 
-from collections import namedtuple, deque
+from collections import deque
 from collections.abc import Iterator
-from typing import Any
+from typing import Any, NamedTuple
 
 from .errors import CircularReferencing
 from .nodes.node import Node
 from .nodes.references import Reference, TypeReference
 from .syntax_tree import SyntaxTree
 
 
+class BfsAttr(NamedTuple):
+    distance: int
+
+
+class DfsAttr(NamedTuple):
+    pass
+
+
+class _DfsState(NamedTuple):
+    node: Node
+    processed: bool
+
+
 class _Traversal(metaclass=ABCMeta):
     def __init__(self, tree: SyntaxTree | Node) -> None:
         self._root: Node = tree.root
@@ -25,16 +38,14 @@ def iterate(self) -> Iterator[tuple[Node, Any]]:
 
 
 class BfsTraversal(_Traversal):
-    def iterate(self) -> Iterator[tuple[Node, Any]]:
-        Attr = namedtuple("Attr", ["distance"])
-
+    def iterate(self) -> Iterator[tuple[Node, BfsAttr]]:
         queue: deque[tuple[Node, int]] = deque([(self._root, 0)])
         processed: set[Node] = set()
         while queue:
             node, distance = queue.popleft()
             if node in processed:
                 continue
-            yield node, Attr(distance=distance)
+            yield node, BfsAttr(distance=distance)
             # We want to preserve original order if possible, and traverse
             # children in *original* order: That way they are popped in order
             for child in _Traversal.children(node):
@@ -47,10 +58,8 @@ class DfsTraversal(_Traversal):
     _PROCESS_NODE_EARLY = 0
     _PROCESS_NODE_LATE = 1
 
-    def _iterate(self) -> Iterator[tuple[int, Node, Any]]:
-        State = namedtuple("State", ["node", "processed"])
-        Attr = namedtuple("Attr", [])
-        stack = [State(node=self._root, processed=False)]
+    def _iterate(self) -> Iterator[tuple[int, Node, DfsAttr]]:
+        stack = [_DfsState(node=self._root, processed=False)]
         discovered: set[Node] = set()
         processed: set[Node] = set()
 
@@ -60,27 +69,27 @@ def _iterate(self) -> Iterator[tuple[int, Node, Any]]:
                 if node in processed:
                     continue
 
-                yield self._PROCESS_NODE_EARLY, node, Attr()
+                yield self._PROCESS_NODE_EARLY, node, DfsAttr()
                 discovered.add(node)
-                stack.append(State(node=node, processed=True))
+                stack.append(_DfsState(node=node, processed=True))
 
                 # We want to preserve original order if possible, and traverse
                 # children in *reverse* order: That way they are popped in order
                 for child in reversed(_Traversal.children(node)):
                     if child not in discovered and child not in processed:
-                        stack.append(State(node=child, processed=False))
+                        stack.append(_DfsState(node=child, processed=False))
                     elif child not in processed:
                         raise CircularReferencing(node, child)
             else:
-                yield self._PROCESS_NODE_LATE, node, Attr()
+                yield self._PROCESS_NODE_LATE, node, DfsAttr()
                 processed.add(node)
 
-    def iterate(self) -> Iterator[tuple[Node, Any]]:
+    def iterate(self) -> Iterator[tuple[Node, DfsAttr]]:
         for event, node, attr in self._iterate():
             if event == self._PROCESS_NODE_EARLY:
                 yield node, attr
 
-    def dependency_order(self) -> Iterator[tuple[Node, Any]]:
+    def dependency_order(self) -> Iterator[tuple[Node, DfsAttr]]:
         for event, node, attr in self._iterate():
             if event == self._PROCESS_NODE_LATE:
                 yield node, attr

flatdata-py/flatdata/lib/resources.py

@@ -181,7 +181,7 @@ class Multivector(ResourceBase):
     def __init__(self, index_mem: Any, mem: Any, index_type: type[Any], *element_types: type[Any]) -> None:
         self._index = Vector(index_mem, index_type)
         self._mem = mem
-        self._element_types = element_types  # type: ignore[assignment]  # tuple from *args; parent declares list but both are indexable at runtime
+        self._element_types = list(element_types)
         self._index_type = index_type
 
     @classmethod