Phase 4

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

Author: VeaaC

flatdata-generator/flatdata/generator/generators/cpp.py

@@ -5,6 +5,8 @@
 
 from jinja2 import Environment
 
+from typing import Any
+
 from flatdata.generator.tree.nodes.resources import Vector, Multivector, Instance, RawData, BoundResource, \
     ResourceBase, Archive as ArchiveResource
 from flatdata.generator.tree.nodes.trivial import Structure, Enumeration, Constant, Field
@@ -24,12 +26,12 @@ def supported_nodes(self) -> list[type]:
     def _populate_environment(self, env: Environment) -> None:
         env.filters["cpp_doc"] = lambda value: value
 
-        def _safe_cpp_string_line(value):
+        def _safe_cpp_string_line(value: str) -> str:
             return value.replace('\\', '\\\\').replace('"', r'\"')
 
         env.filters["safe_cpp_string_line"] = _safe_cpp_string_line
 
-        def _cpp_base_type(flatdata_type):
+        def _cpp_base_type(flatdata_type: Any) -> str:
             type_map = {
                 "bool": "bool",
                 "i8": "int8_t",
@@ -43,28 +45,28 @@ def _cpp_base_type(flatdata_type):
             }
             if flatdata_type.name in type_map:
                 return type_map[flatdata_type.name]
-            return flatdata_type.name.replace("@@", "::").replace("@", "::")
+            return str(flatdata_type.name.replace("@@", "::").replace("@", "::"))
 
         env.filters["cpp_base_type"] = _cpp_base_type
 
-        def _to_type_params(refs):
+        def _to_type_params(refs: list[Any]) -> str:
             return ', '.join([ref.node.path_with("::") for ref in refs])
 
         env.filters["to_type_params"] = _to_type_params
 
-        def _snake_to_upper_camel_case(expr):
+        def _snake_to_upper_camel_case(expr: str) -> str:
             return ''.join(p.title() for p in expr.split('_'))
 
         env.filters["snake_to_upper_camel_case"] = _snake_to_upper_camel_case
 
-        def _typedef_name(entity, extra_suffix=""):
+        def _typedef_name(entity: Any, extra_suffix: str = "") -> str:
             assert isinstance(entity, (Field, ResourceBase)), "Got: %s" % entity.__class__
             return _snake_to_upper_camel_case(entity.name) + extra_suffix + "Type"
 
         env.filters["typedef_name"] = _typedef_name
 
-        def _optional_typedef_usage(resource, extra_suffix=""):
-            def _wrap_in_optional(declaration):
+        def _optional_typedef_usage(resource: Any, extra_suffix: str = "") -> str:
+            def _wrap_in_optional(declaration: str) -> str:
                 if resource.optional:
                     return "boost::optional< %s >" % declaration
                 return declaration
@@ -73,7 +75,7 @@ def _wrap_in_optional(declaration):
 
         env.filters["archive_typedef_usage"] = _optional_typedef_usage
 
-        def _resource_provides_incremental_builder(resource):
+        def _resource_provides_incremental_builder(resource: Any) -> bool:
             assert isinstance(resource, ResourceBase)
             if isinstance(resource, Instance):
                 return False
@@ -88,7 +90,7 @@ def _resource_provides_incremental_builder(resource):
         env.filters[
             "resource_provides_incremental_builder"] = _resource_provides_incremental_builder
 
-        def provides_setter(resource):
+        def provides_setter(resource: Any) -> bool:
             assert isinstance(resource, ResourceBase)
             if isinstance(resource, Instance):
                 return True

flatdata-generator/flatdata/generator/generators/dot.py

@@ -6,6 +6,8 @@
 from flatdata.generator.tree.nodes.archive import Archive
 from . import BaseGenerator
 
+from typing import Any
+
 from jinja2 import Environment
 
 SCOPE_SEPARATOR = "__"
@@ -21,9 +23,9 @@ def __init__(self) -> None:
     def _populate_environment(self, env: Environment) -> None:
         env.autoescape = True
 
-        def _field_value_type(field):
-            type_name = field.type.name.replace("@@", ".").replace("@", ".")
-            namespace_name = field.parent.parent.path
+        def _field_value_type(field: Any) -> str:
+            type_name = str(field.type.name).replace("@@", ".").replace("@", ".")
+            namespace_name = str(field.parent.parent.path)
             if type_name.startswith(namespace_name):
                 type_name = type_name[len(namespace_name):]
             if type_name.startswith("."):

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

@@ -5,6 +5,8 @@
 
 from jinja2 import Environment
 
+from typing import Any
+
 from flatdata.generator.tree.nodes.resources import BoundResource
 from flatdata.generator.tree.nodes.trivial import Structure, Enumeration, Constant
 from flatdata.generator.tree.nodes.archive import Archive
@@ -22,19 +24,19 @@ def supported_nodes(self) -> list[type]:
         return [Structure, Archive, Constant, Enumeration]
 
     def _populate_environment(self, env: Environment) -> None:
-        def _is_builtin(node):
+        def _is_builtin(node: Any) -> bool:
             for namespace in SyntaxTree.namespaces(node):
                 if namespace.name == "_builtin":
                     return True
             return False
         env.filters["filter_builtin"] = lambda l: [x for x in l if not _is_builtin(x)]
 
-        def _field_type(flatdata_type):
+        def _field_type(flatdata_type: str) -> str:
             return flatdata_type.replace("@@", ".").replace("@", ".")
 
         env.filters["field_type"] = _field_type
 
-        def _to_type_params(refs):
+        def _to_type_params(refs: list[Any]) -> str:
             return ', '.join([ref.node.path_with(".") for ref in refs if not _is_builtin(ref.node)])
 
         env.filters["to_type_params"] = _to_type_params

flatdata-generator/flatdata/generator/generators/go.py

@@ -4,6 +4,8 @@
 '''
 from jinja2 import Environment
 
+from typing import Any
+
 from flatdata.generator.tree.nodes.archive import Archive
 from flatdata.generator.tree.nodes.node import Node
 from flatdata.generator.tree.nodes.resources import Instance, Vector, Multivector, RawData
@@ -23,25 +25,25 @@ def supported_nodes(self) -> list[type]:
         return [Structure, Archive, Constant]
 
     def _populate_environment(self, env: Environment) -> None:
-        def _decorate_archive_type(value):
+        def _decorate_archive_type(value: Node) -> str:
             assert isinstance(value, Node)
-            return value.name
+            return str(value.name)
 
-        def to_go_doc(value):
+        def to_go_doc(value: Any) -> str:
             lines = value.doc.splitlines()
             return '\n'.join(["// " + s for s in lines if len(s) != 0])
 
-        def type_mapping(flatdata_type, _struct):
+        def type_mapping(flatdata_type: str, _struct: Any) -> str:
             if is_bool(flatdata_type):
                 return "uint8"
             return go_mapping(flatdata_type)
 
-        def type_mapping_with_bool(flatdata_type):
+        def type_mapping_with_bool(flatdata_type: str) -> str:
             if is_bool(flatdata_type):
                 return "bool"
             return go_mapping(flatdata_type)
 
-        def go_mapping(flatdata_type):
+        def go_mapping(flatdata_type: str) -> str:
             return {
                 "i8": "int8",
                 "u8": "uint8",
@@ -53,15 +55,15 @@ def go_mapping(flatdata_type):
                 "i64": "int64"
             }[flatdata_type]
 
-        def is_bool(flatdata_type):
+        def is_bool(flatdata_type: str) -> bool:
             return flatdata_type == "bool"
 
-        def to_go_case(name, exported=True):
+        def to_go_case(name: str, exported: bool = True) -> str:
             if "_" in name:
                 name = "".join(part.title() for part in name.split("_"))
             return (str.upper if exported else str.lower)(str(name[0])) + str(name[1:])
 
-        def to_initializer(resource, tree):
+        def to_initializer(resource: Any, tree: Any) -> str:
             if isinstance(resource, Instance):
                 return _decorate_archive_type(resource.referenced_structures[0].node)
             if isinstance(resource, Vector):
@@ -77,10 +79,10 @@ def to_initializer(resource, tree):
                 return "None"
             raise ValueError("Unknown resource type: %s" % (resource.__class__))
 
-        def get_types_for_multivector(resource, _tree):
+        def get_types_for_multivector(resource: Any, _tree: Any) -> list[str]:
             return [_decorate_archive_type(t.node) for t in resource.referenced_structures]
 
-        def contains_archive_resource(tree):
+        def contains_archive_resource(tree: Any) -> bool:
             for child in tree.root.children[0].children:
                 for res in child.children:
                     if isinstance(res, ArchiveResource):

flatdata-generator/flatdata/generator/generators/python.py

@@ -4,6 +4,8 @@
 '''
 from jinja2 import Environment
 
+from typing import Any
+
 from flatdata.generator.tree.nodes.resources import Instance, Vector, Multivector, RawData
 from flatdata.generator.tree.nodes.resources.archive import Archive as ArchiveResource
 from flatdata.generator.tree.nodes.trivial import Structure
@@ -22,18 +24,18 @@ def supported_nodes(self) -> list[type]:
         return [Structure, Archive]
 
     def _populate_environment(self, env: Environment) -> None:
-        def _decorate_archive_type(tree, value):
+        def _decorate_archive_type(tree: Any, value: Node) -> str:
             assert isinstance(value, Node)
-            return tree.namespace_path(value, "_") + "_" + value.name
+            return str(tree.namespace_path(value, "_") + "_" + value.name)
 
-        def to_python_doc(value):
+        def to_python_doc(value: str) -> str:
             return '\n'.join(
                 ["# " + line.replace('/**', '', 1).replace('*/', '', 1).replace(" *", '',
                                                                                 1).replace("//", "",
                                                                                            1) for
                  line in value.splitlines()])
 
-        def to_container(resource):
+        def to_container(resource: Any) -> str:
             if isinstance(resource, Instance):
                 return "flatdata.resources.Instance"
             if isinstance(resource, Vector):
@@ -46,22 +48,22 @@ def to_container(resource):
                 return "flatdata.archive.Archive"
             raise ValueError("Unknown resource type: %s" % (resource.__class__))
 
-        def to_initializer(resource, tree):
+        def to_initializer(resource: Any, tree: Any) -> str:
             if isinstance(resource, Instance):
-                return _decorate_archive_type(tree, resource.referenced_structures[0].node)
+                return str(_decorate_archive_type(tree, resource.referenced_structures[0].node))
             if isinstance(resource, Vector):
-                return _decorate_archive_type(tree, resource.referenced_structures[0].node)
+                return str(_decorate_archive_type(tree, resource.referenced_structures[0].node))
             if isinstance(resource, Multivector):
                 return "[{}]".format(
                     ','.join([_decorate_archive_type(tree, t.node) for t in
                               resource.referenced_structures]))
             if isinstance(resource, ArchiveResource):
-                return _decorate_archive_type(tree, resource.children[0].node)  # type: ignore[attr-defined]  # child is an ArchiveReference which has .node
+                return str(_decorate_archive_type(tree, resource.children[0].node))  # type: ignore[attr-defined]  # child is an ArchiveReference which has .node
             if isinstance(resource, RawData):
                 return "None"
             raise ValueError("Unknown resource type: %s" % (resource.__class__))
 
-        def to_dtype(field):
+        def to_dtype(field: Any) -> str:
             type_map = {
                 "bool": "?",
                 "i8": "b",
@@ -75,9 +77,9 @@ def to_dtype(field):
             }
             if field.type.name in type_map:
                 return type_map[field.type.name]
-            return type_map[field.type_reference.node.type.name]
+            return str(type_map[field.type_reference.node.type.name])
 
-        def _safe_py_string_line(value):
+        def _safe_py_string_line(value: str) -> str:
             return value.replace('\\', '\\\\').replace('"', r'\"')
 
         env.filters["safe_py_string_line"] = _safe_py_string_line

flatdata-generator/flatdata/generator/generators/rust.py

@@ -6,6 +6,8 @@
 
 from jinja2 import Environment
 
+from typing import Any
+
 from flatdata.generator.tree.nodes.resources import (Vector, Multivector, Instance, RawData, BoundResource,
                                             Archive as ArchiveResource)
 from flatdata.generator.tree.nodes.trivial import Structure, Constant, Enumeration
@@ -43,18 +45,18 @@ def _format_numeric_literal(value: str) -> str:
             return value
 
     def _populate_environment(self, env: Environment) -> None:
-        def _camel_to_snake_case(expr):
+        def _camel_to_snake_case(expr: str) -> str:
             step1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', expr)
             return re.sub('([a-z0-9])(A-Z)', r'\1_\2', step1).lower()
 
         env.filters["camel_to_snake_case"] = _camel_to_snake_case
 
-        def _snake_to_upper_camel_case(expr):
+        def _snake_to_upper_camel_case(expr: str) -> str:
             return ''.join(p.title() for p in expr.split('_'))
 
         env.filters["snake_to_upper_camel_case"] = _snake_to_upper_camel_case
 
-        def _rust_doc(expr):
+        def _rust_doc(expr: str) -> str:
             lines = [
                 re.sub(r'^[ \t]*(/\*\*\s?|/\*\s?|\*/|\*\s?)(.*?)\s*(\*/)?$',
                        r"/// \2", line).strip()
@@ -70,24 +72,24 @@ def _rust_doc(expr):
 
         env.filters["rust_doc"] = _rust_doc
 
-        def _escape_rust_keywords(expr):
+        def _escape_rust_keywords(expr: str) -> str:
             if expr in self.RESERVED_KEYWORDS:
                 return "{}_".format(expr)
             return expr
 
-        def _field_type(field):
+        def _field_type(field: Any) -> str:
             if isinstance(field.type, EnumType):
                 return "{}".format(
                     _fully_qualified_name(field.parent, field.type_reference.node))
             return "{}".format(field.type.name)
 
-        def _primitive_type(field):
+        def _primitive_type(field: Any) -> str:
             if isinstance(field.type, EnumType):
                 return "{}".format(field.type_reference.node.type.name)
             return "{}".format(field.type.name)
 
-        def _fully_qualified_name(current, node):
-            return "::".join((current.path_depth() - 1) * ["super"]) + node.path_with("::")
+        def _fully_qualified_name(current: Any, node: Any) -> str:
+            return "::".join((current.path_depth() - 1) * ["super"]) + str(node.path_with("::"))
 
         env.globals["fully_qualified_name"] = _fully_qualified_name
         env.filters["escape_rust_keywords"] = _escape_rust_keywords

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

@@ -40,8 +40,8 @@ def index_reference(self) -> BuiltinStructureReference:
 
     @property
     def builtins(self) -> list[Structure]:
-        class MemberDict(dict):
-            def __getattr__(self, attr):
+        class MemberDict(dict):  # type: ignore[type-arg]  # intentionally unparameterized: mimics dynamic attribute access
+            def __getattr__(self, attr: str) -> Any:
                 return self.get(attr)
         decorations = [MemberDict({"range" : MemberDict({"name":"range"})})]
         field = MemberDict({"decorations":decorations, "name":"value", "width":self._width, "type":"u64"})

flatdata-generator/pyproject.toml

@@ -47,12 +47,13 @@ namespace_packages = true
 explicit_package_bases = true
 warn_return_any = true
 warn_unused_configs = true
-disallow_untyped_defs = false
+disallow_untyped_defs = true
 check_untyped_defs = true
 warn_redundant_casts = true
 warn_unused_ignores = true
 no_implicit_optional = true
 strict_equality = true
+disallow_any_generics = true
 
 [[tool.mypy.overrides]]
 module = "Levenshtein"

flatdata-py/flatdata/lib/archive_builder.py

@@ -197,10 +197,10 @@ def __set_multivector(self, storage: Any, name: str, value: list[list[dict[str,
         for index, obj_type in enumerate(initializer_list[1:]):
             initializers[obj_type._NAME] = (index, obj_type)
 
-        def valid_structure_name(_obj):
+        def valid_structure_name(_obj: dict[str, Any]) -> bool:
             return _obj['name'] in [_initializer._NAME for _initializer in initializer_list[1:]]
 
-        def validate_fields(_obj):
+        def validate_fields(_obj: dict[str, Any]) -> None:
             matched_obj_list = [
                 _initializer for _initializer in initializer_list[1:] \
                     if _initializer._NAME == _obj['name']]