Review feedback

Signed-off-by: Christian Vetter <christian.vetter@here.com>

Author: VeaaC

flatdata-generator/flatdata/generator/engine.py

@@ -82,7 +82,7 @@ def render_python_module(self, module_name: str | None = None, archive_name: str
             return module
 
         name = ns.name + "_" + archive_name
-        archive_type = getattr(module, name) if archive_name else None
+        archive_type = getattr(module, name)
         return module, archive_type
 
     @classmethod

flatdata-generator/flatdata/generator/generators/__init__.py

@@ -4,7 +4,7 @@
 '''
 
 from abc import ABCMeta, abstractmethod
-from typing import Any
+from typing import Any, NoReturn
 
 from jinja2 import Environment, PackageLoader
 from jinja2 import nodes
@@ -83,6 +83,6 @@ def parse(self, parser: Any) -> nodes.CallBlock:
         )
 
     #pylint: disable=no-self-use
-    def _raise(self, msg: str, caller: Any) -> str:
+    def _raise(self, msg: str, caller: Any) -> NoReturn:
         """Helper callback."""
         raise TemplateRuntimeError(msg)

flatdata-generator/flatdata/generator/tree/builder.py

@@ -163,6 +163,7 @@ def _compute_structure_sizes(root: Root) -> None:
             if not isinstance(field, nodes.Field):
                 continue
             field.offset = offset
+            assert field.type is not None
             offset += int(field.type.width)
         struct.size_in_bits = offset
 
@@ -200,6 +201,7 @@ def _check_ranges(root: Root) -> None:
 
 def _check_const_refs(root: Root) -> None:
     for field in root.iterate(nodes.Field):
+        assert field.type is not None
         for ref in field.children_like(ConstantReference):
             const_node = ref.node  # resolves to Constant at runtime
             # Check that type matches

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

@@ -48,8 +48,8 @@ def create(properties: Any, definition: Any) -> 'Archive':
         return result
 
     @property
-    def resources(self) -> list[Any]:
-        return self.children_like(resources.ResourceBase)
+    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:

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

@@ -72,14 +72,16 @@ def parent(self) -> Node | None:
         """
         return self._parent
 
-    def first_parent_like(self, T: type) -> Node | None:
+    def first_parent_like(self, T: type[_T]) -> _T | None:
         """
         Returns first available parent of a given type or None if none found.
         """
         result = self
         while result.parent is not None and not isinstance(result.parent, T):
             result = result.parent
-        return result.parent
+        if isinstance(result.parent, T):
+            return result.parent
+        return None
 
     @property
     def path(self) -> str:

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

@@ -36,7 +36,7 @@ def decorations(self) -> list[Any]:
         return self._decorations
 
     @property
-    def explicit_references(self) -> list[Any]:
+    def explicit_references(self) -> list[ExplicitReference]:
         return self.children_like(ExplicitReference)
 
     @property

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

@@ -60,5 +60,5 @@ def type(self) -> BasicType | None:
         return self._type
 
     @property
-    def values(self) -> list[Any]:
+    def values(self) -> list[EnumerationValue]:
         return self.children_like(EnumerationValue)

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

@@ -1,6 +1,7 @@
 from flatdata.generator.tree.nodes.node import Node
 from flatdata.generator.tree.nodes.references import EnumerationReference, ConstantValueReference, InvalidValueReference
 from flatdata.generator.tree.helpers.basictype import BasicType
+from flatdata.generator.tree.helpers.enumtype import EnumType
 
 from typing import Any
 
@@ -23,7 +24,7 @@ def __init__(self, name: str, properties: Any = None, type: str | None = None, o
         if type is not None:
             if not BasicType.is_basic_type(type):
                 self._type_reference = EnumerationReference(type, width=self._width)
-                self._type: BasicType | Any | None = None
+                self._type: BasicType | EnumType | None = None
                 self.insert(self._type_reference)
             else:
                 self._type = BasicType(name=type, width=self._width)
@@ -47,11 +48,11 @@ def range(self) -> str | None:
         return None
 
     @property
-    def const_value_refs(self) -> list[Any]:
+    def const_value_refs(self) -> list[ConstantValueReference]:
         return self.children_like(ConstantValueReference)
 
     @property
-    def invalid_value(self) -> Any:
+    def invalid_value(self) -> InvalidValueReference | None:
         for x in self.children_like(InvalidValueReference):
             return x
         return None
@@ -61,11 +62,11 @@ def decorations(self) -> list[Any]:
         return self._decorations
 
     @property
-    def type(self) -> Any:
+    def type(self) -> BasicType | EnumType | None:
         return self._type
 
     @type.setter
-    def type(self, value: Any) -> None:
+    def type(self, value: BasicType | EnumType | None) -> None:
         self._type = value
 
     @property

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

@@ -44,5 +44,5 @@ def size_in_bytes(self) -> int:
         return (self._size_in_bits + 7) // 8
 
     @property
-    def fields(self) -> list[Any]:
+    def fields(self) -> list[Field]:
         return self.children_like(Field)

flatdata-generator/flatdata/generator/tree/resolver.py

@@ -64,10 +64,11 @@ def _validate_target_type(root: Node, ref: refs.Reference) -> None:
         raise errors.IncorrectReferenceType(ref.name, type(target), expected)
 
 
-def resolve_references(tree: Any) -> None:
+def resolve_references(tree: Node) -> None:
     for node in tree.root.iterate():
         assert type(node) not in _RESOLVED_BASE_TYPES, "Base reference types should not be used directly"
         if any([issubclass(type(node), t) for t in _RESOLVED_BASE_TYPES]):
+            assert isinstance(node, refs.Reference)
             if node.is_qualified:
                 resolved = _resolve_as_fully_qualified_reference(node)
             else: