flatdata-generator 0.4.10__tar.gz → 0.4.12__tar.gz

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/.gitignore

@@ -4,10 +4,6 @@ build
 venv*
 **/.vscode/**
 **/.idea/**
-**/*_generated.go
-**/coverage.out
-**/flatdata-fuzz.zip
-**/corpus/**
 **/dist/**
 *.egg-info
 .DS_Store

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: flatdata-generator
-Version: 0.4.10
-Summary: Generate source code for C++, Rust, Go or Python from a Flatdata schema file
+Version: 0.4.12
+Summary: Generate source code for C++, Rust, or Python from a Flatdata schema file
 Project-URL: Homepage, https://github.com/heremaps/flatdata
 Author: Flatdata Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
 Requires-Dist: jinja2>=2.2
 Requires-Dist: pyparsing>=2.0
 Description-Content-Type: text/markdown
@@ -29,12 +30,31 @@ pip3 install flatdata-generator
 flatdata-generator -s locations.flatdata -g cpp -O locations.hpp
 ```
 
+### Multi-file Schemas
+
+When a schema uses `import` statements, each file should be generated
+separately. Imported types are referenced via include/import directives rather
+than being re-emitted:
+
+```sh
+# Generate shared types
+flatdata-generator -s schema/types.flatdata -g cpp -O schema/types.h
+
+# Generate main schema (will #include "types.h")
+flatdata-generator -s schema/main.flatdata -g cpp -O schema/main.h
+```
+
+For Rust, the same approach applies — each imported file becomes its own module
+with `pub use` re-exports connecting the namespaces.
+
+Python and Dot generators emit all types monolithically (no separate generation
+needed for the root file — all imported definitions are included in the output).
+
 Currently supported target languages:
 
 * C++
 * Rust
 * Python
-* Go
 * Dot (graph of the schema)
 * Flatdata (normalized stable schema)
 
@@ -44,9 +64,14 @@ Currently supported target languages:
 
 The `flatdata` generator works in several stages which are clearly separated from one another and can be extended/tested in isolation:
 
-1. **Parse the source schema** file using `pyparsing` library. Grammar
+1. **Resolve imports** starting from the root schema file. The importer
+   (`importer.py`) performs a depth-first traversal of import statements,
+   deduplicating files and handling cyclic imports. The result is an ordered
+   list of resolved files with their parsed content.
+
+2. **Parse the source schema** file using `pyparsing` library. Grammar
    for the schema is defined in `grammar.py`
-2. **Construct a node tree** out of `pyparsing.ParseResults`. The node tree
+3. **Construct a node tree** out of `pyparsing.ParseResults`. The node tree
    contains entities for every construct of flatdata grammar, organized
    in hierarchical order, allowing non-tree references between nodes:
 
@@ -63,7 +88,7 @@ The `flatdata` generator works in several stages which are clearly separated fro
       -  `TypeReference` - model type dependencies, which are used during
          topological sorting at a later stage and for schema resolution.
 
-3. **Augment the tree** with structures and references that are not
+4. **Augment the tree** with structures and references that are not
    directly corresponding to `pyparsing.ParseResults` or needed to
    implement advanced features. Among these:
 
@@ -73,17 +98,17 @@ The `flatdata` generator works in several stages which are clearly separated fro
    -  **Add constant references** to all archives so that constants are
       available for schema resolution.
 
-4. **Resolve references** iterates through all references and tries to
+5. **Resolve references** iterates through all references and tries to
    find a node they refer to, either in:
 
    -  Parent scopes until (inclusive) innermost parent namespace.
    -  Root node if path is fully qualified.
 
-5. **Perform topological sorting** to detect cycles in between entities
+6. **Perform topological sorting** to detect cycles in between entities
    and to determine the order of serialization for targets that depend
    on one.
 
-6. **Generate the source code** using nodes in topological order *and/or*
+7. **Generate the source code** using nodes in topological order *and/or*
    the tree (depending on the generator architecture - recursive descent
    or iterative).
 
@@ -101,6 +126,11 @@ Node tree enforces several properties of the flatdata schema:
    participate in topological sorting of the DAG formed by the tree
    edges and edges between source and target of a `TypeReference`
 
+When building a tree from multiple files, each node is tagged with its
+`source_file` (the file it was defined in) and an `is_local` flag
+(whether it belongs to the root file being generated). This allows
+generators to filter nodes for separate compilation.
+
 ### References
 
 Reference names are mangled so they are not ambiguous with other paths

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/README.md

@@ -16,12 +16,31 @@ pip3 install flatdata-generator
 flatdata-generator -s locations.flatdata -g cpp -O locations.hpp
 ```
 
+### Multi-file Schemas
+
+When a schema uses `import` statements, each file should be generated
+separately. Imported types are referenced via include/import directives rather
+than being re-emitted:
+
+```sh
+# Generate shared types
+flatdata-generator -s schema/types.flatdata -g cpp -O schema/types.h
+
+# Generate main schema (will #include "types.h")
+flatdata-generator -s schema/main.flatdata -g cpp -O schema/main.h
+```
+
+For Rust, the same approach applies — each imported file becomes its own module
+with `pub use` re-exports connecting the namespaces.
+
+Python and Dot generators emit all types monolithically (no separate generation
+needed for the root file — all imported definitions are included in the output).
+
 Currently supported target languages:
 
 * C++
 * Rust
 * Python
-* Go
 * Dot (graph of the schema)
 * Flatdata (normalized stable schema)
 
@@ -31,9 +50,14 @@ Currently supported target languages:
 
 The `flatdata` generator works in several stages which are clearly separated from one another and can be extended/tested in isolation:
 
-1. **Parse the source schema** file using `pyparsing` library. Grammar
+1. **Resolve imports** starting from the root schema file. The importer
+   (`importer.py`) performs a depth-first traversal of import statements,
+   deduplicating files and handling cyclic imports. The result is an ordered
+   list of resolved files with their parsed content.
+
+2. **Parse the source schema** file using `pyparsing` library. Grammar
    for the schema is defined in `grammar.py`
-2. **Construct a node tree** out of `pyparsing.ParseResults`. The node tree
+3. **Construct a node tree** out of `pyparsing.ParseResults`. The node tree
    contains entities for every construct of flatdata grammar, organized
    in hierarchical order, allowing non-tree references between nodes:
 
@@ -50,7 +74,7 @@ The `flatdata` generator works in several stages which are clearly separated fro
       -  `TypeReference` - model type dependencies, which are used during
          topological sorting at a later stage and for schema resolution.
 
-3. **Augment the tree** with structures and references that are not
+4. **Augment the tree** with structures and references that are not
    directly corresponding to `pyparsing.ParseResults` or needed to
    implement advanced features. Among these:
 
@@ -60,17 +84,17 @@ The `flatdata` generator works in several stages which are clearly separated fro
    -  **Add constant references** to all archives so that constants are
       available for schema resolution.
 
-4. **Resolve references** iterates through all references and tries to
+5. **Resolve references** iterates through all references and tries to
    find a node they refer to, either in:
 
    -  Parent scopes until (inclusive) innermost parent namespace.
    -  Root node if path is fully qualified.
 
-5. **Perform topological sorting** to detect cycles in between entities
+6. **Perform topological sorting** to detect cycles in between entities
    and to determine the order of serialization for targets that depend
    on one.
 
-6. **Generate the source code** using nodes in topological order *and/or*
+7. **Generate the source code** using nodes in topological order *and/or*
    the tree (depending on the generator architecture - recursive descent
    or iterative).
 
@@ -88,6 +112,11 @@ Node tree enforces several properties of the flatdata schema:
    participate in topological sorting of the DAG formed by the tree
    edges and edges between source and target of a `TypeReference`
 
+When building a tree from multiple files, each node is tagged with its
+`source_file` (the file it was defined in) and an `is_local` flag
+(whether it belongs to the root file being generated). This allows
+generators to filter nodes for separate compilation.
+
 ### References
 
 Reference names are mangled so they are not ambiguous with other paths

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/flatdata/generator/app.py

@@ -19,9 +19,10 @@ except ModuleNotFoundError as exc:
 
 from flatdata.generator.engine import Engine
 from flatdata.generator.tree.errors import FlatdataSyntaxError
+from flatdata.generator.tree.syntax_tree import SyntaxTree
 
 
-def _parse_command_line():
+def _parse_command_line() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Generates code for a given flatdata schema file.")
     parser.add_argument("-s", "--schema", type=str, required=True,
@@ -32,6 +33,8 @@ def _parse_command_line():
     parser.add_argument("-O", "--output-file", type=str, required=True,
                         default=None,
                         help="Destination file. Forces all output to be stored in one file")
+    parser.add_argument("-d", "--depfile", type=str, default=None,
+                        help="Write a Makefile-style dependency file listing all imported schemas")
     parser.add_argument("-v", "--verbose", action="store_true",
                         help="Enable verbose mode")
     parser.add_argument("--debug", action="store_true",
@@ -39,7 +42,7 @@ def _parse_command_line():
     return parser.parse_args()
 
 
-def _setup_logging(args):
+def _setup_logging(args: argparse.Namespace) -> None:
     level = logging.WARNING
     if args.debug:
         level = logging.DEBUG
@@ -52,24 +55,22 @@ def _setup_logging(args):
         level=level)
 
 
-def _check_args(args):
+def _check_args(args: argparse.Namespace) -> None:
     if not os.path.isfile(args.schema):
         logging.fatal("Cannot find schema file at %s", args.schema)
         sys.exit(1)
 
 
-def _run(args):
+def _run(args: argparse.Namespace) -> None:
     _setup_logging(args)
     _check_args(args)
 
-    with open(args.schema, 'r') as input_file:
-        schema = input_file.read()
-        try:
-            engine = Engine(schema)
-            logging.debug("Tree: %s", engine.tree)
-        except FlatdataSyntaxError as ex:
-            logging.fatal("Error reading schema: %s ", ex)
-            sys.exit(1)
+    try:
+        engine = Engine.from_file(args.schema)
+        logging.debug("Tree: %s", engine.tree)
+    except FlatdataSyntaxError as ex:
+        logging.fatal("Error reading schema: %s ", ex)
+        sys.exit(1)
 
     try:
         logging.info("Generating %s...", args.gen)
@@ -85,7 +86,27 @@ def _run(args):
         output.write(output_content)
         logging.info("Code for %s is written to %s", args.gen, args.output_file)
 
+    if args.depfile:
+        _write_depfile(args.depfile, args.output_file, args.schema, engine.tree)
+
+
+def _write_depfile(depfile_path: str, output_file: str, schema_file: str,
+                   tree: 'SyntaxTree') -> None:
+    """Write a Makefile-style depfile listing all schema dependencies."""
+    deps = [os.path.abspath(schema_file)]
+    # source_file_map keys are absolute paths of all imported files
+    deps.extend(sorted(tree.source_file_map.keys()))
+
+    # Escape spaces in paths for Make syntax
+    def escape(p: str) -> str:
+        return p.replace(" ", "\\ ")
+
+    dep_str = " ".join(escape(d) for d in deps)
+    with open(depfile_path, "w") as f:
+        f.write(f"{escape(output_file)}: {dep_str}\n")
+    logging.info("Depfile written to %s", depfile_path)
+
 
-def main():
+def main() -> None:
     """Entrypoint"""
     _run(_parse_command_line())

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/flatdata/generator/engine.py

@@ -3,18 +3,22 @@
  See the LICENSE file in the root of this project for license details.
 '''
 
+from __future__ import annotations
+
 import types
+from typing import overload
 
-from flatdata.generator.tree.builder import build_ast
+from flatdata.generator.tree.builder import build_ast, build_ast_from_file
 from flatdata.generator.tree.nodes.trivial.namespace import Namespace
 from flatdata.generator.tree.nodes.node import Node
+from flatdata.generator.tree.syntax_tree import SyntaxTree
 
 from .generators.cpp import CppGenerator
 from .generators.dot import DotGenerator
-from .generators.go import GoGenerator
 from .generators.python import PythonGenerator
 from .generators.rust import RustGenerator
 from .generators.flatdata import FlatdataGenerator
+from .generators import BaseGenerator
 
 
 class Engine:
@@ -23,23 +27,33 @@ class Engine:
     Implements code generation from the given flatdata schema.
     """
 
-    _GENERATORS = {
+    _GENERATORS: dict[str, type[BaseGenerator]] = {
         "cpp": CppGenerator,
         "dot": DotGenerator,
-        "go": GoGenerator,
         "py": PythonGenerator,
         "rust": RustGenerator,
         "flatdata" : FlatdataGenerator
     }
 
     @classmethod
-    def available_generators(cls):
+    def available_generators(cls) -> list[str]:
         """
         Lists names of available code generators.
         """
         return list(cls._GENERATORS.keys())
 
-    def __init__(self, schema):
+    @classmethod
+    def from_file(cls, path: str) -> 'Engine':
+        """
+        Create Engine from a schema file, resolving imports.
+        :raises FlatdataSyntaxError
+        """
+        engine = cls.__new__(cls)
+        engine.tree = build_ast_from_file(path)
+        engine.schema = engine.tree.root_schema or ""
+        return engine
+
+    def __init__(self, schema: str) -> None:
         """
         Instantiates generator engine for a given schema.
         :raises FlatdataSyntaxError
@@ -47,7 +61,7 @@ class Engine:
         self.schema = schema
         self.tree = build_ast(schema)
 
-    def render(self, generator_name):
+    def render(self, generator_name: str) -> str:
         """
         Render schema with a given generator
         :param generator_name:
@@ -60,9 +74,16 @@ class Engine:
             )
 
         output_content = generator.render(self.tree)
-        return output_content
+        return str(output_content)
+
+    @overload
+    def render_python_module(self, module_name: str | None, archive_name: str, root_namespace: str | None = None) -> tuple[types.ModuleType, type]: ...
+    @overload
+    def render_python_module(self, *, archive_name: str, root_namespace: str | None = None) -> tuple[types.ModuleType, type]: ...
+    @overload
+    def render_python_module(self, module_name: str | None = None, archive_name: None = None, root_namespace: str | None = None) -> types.ModuleType: ...
 
-    def render_python_module(self, module_name=None, archive_name=None, root_namespace=None):
+    def render_python_module(self, module_name: str | None = None, archive_name: str | None = None, root_namespace: str | None = None) -> types.ModuleType | tuple[types.ModuleType, type]:
         """
         Render python module.
         :param module_name: Module name to use. If none, root namespace name is used.
@@ -70,28 +91,28 @@ class Engine:
             if specified, archive type is returned along with the model
         :param root_namespace: Root namespace to pick in case of multiple top level namespaces.
         """
-        root_namespace = self._find_root_namespace(self.tree, archive_name, root_namespace)
+        ns = self._find_root_namespace(self.tree, archive_name, root_namespace)
         module_code = self.render("py")
-        module = types.ModuleType(module_name if module_name is not None else root_namespace.name)
+        module = types.ModuleType(module_name if module_name is not None else ns.name)
         #pylint: disable=exec-used
         exec(module_code, module.__dict__)
         if archive_name is None:
             return module
 
-        name = root_namespace.name + "_" + archive_name
-        archive_type = getattr(module, name) if archive_name else None
+        name = ns.name + "_" + archive_name
+        archive_type = getattr(module, name)
         return module, archive_type
 
     @classmethod
-    def _create_generator(cls, name):
+    def _create_generator(cls, name: str) -> BaseGenerator | None:
         generator_type = cls._GENERATORS.get(name, None)
         if generator_type is None:
             return None
 
-        return generator_type()
+        return generator_type()  # type: ignore[call-arg]  # dict values are concrete subclasses with zero-arg __init__
 
     @staticmethod
-    def _find_root_namespace(tree, archive_name, root_namespace=None):
+    def _find_root_namespace(tree: SyntaxTree, archive_name: str | None, root_namespace: str | None = None) -> Namespace:
         root_children = tree.root.children
         root_namespaces = [
             child for child in root_children

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

@@ -0,0 +1,109 @@
+'''
+ Copyright (c) 2017 HERE Europe B.V.
+ See the LICENSE file in the root of this project for license details.
+'''
+
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import NoReturn
+
+from jinja2 import Environment, PackageLoader
+from jinja2 import nodes
+from jinja2.ext import Extension
+from jinja2.exceptions import TemplateRuntimeError
+from jinja2.parser import Parser
+
+from flatdata.generator.tree.nodes.archive import Archive
+from flatdata.generator.tree.nodes.node import Node
+from flatdata.generator.tree.nodes.trivial import Structure, Enumeration, Constant, Namespace
+from flatdata.generator.tree.nodes.references import EnumerationReference
+from flatdata.generator.tree.nodes.resources import ResourceBase, BoundResource, Archive as \
+    ArchiveResource, Vector, Multivector, Instance, RawData
+from flatdata.generator.tree.syntax_tree import SyntaxTree
+from flatdata.generator.tree.traversal import DfsTraversal
+
+
+class BaseGenerator(metaclass=ABCMeta):
+    """Abstract base class for Flatdata generators"""
+
+    def __init__(self, template: str) -> None:
+        self._template = template
+        self._env: Environment | None = None
+
+    @abstractmethod
+    def supported_nodes(self) -> list[type]:
+        """List of supported nodes by this generator"""
+        raise RuntimeError(
+            "Derived generators must implement _supported_nodes")
+
+    @abstractmethod
+    def _populate_environment(self, env: Environment, tree: SyntaxTree) -> None:
+        raise RuntimeError(
+            "Derived generators must implement _populate_filters")
+
+    def filter_nodes(self, nodes: list[Node], tree: SyntaxTree) -> list[Node]:
+        """Filter nodes for rendering. Override for separate compilation."""
+        return nodes
+
+    def get_import_directives(self, tree: SyntaxTree) -> list[str]:
+        """Return language-specific import directives. Override in subclasses."""
+        return []
+
+    def _get_environment(self, tree: SyntaxTree) -> Environment:
+        if self._env is None:
+            env = Environment(loader=PackageLoader('flatdata.generator', 'templates'), lstrip_blocks=True,
+                              trim_blocks=True, autoescape=False, extensions=[RaiseExtension])
+            env.filters['is_archive'] = lambda n: isinstance(n, Archive)
+            env.filters['is_instance'] = lambda n: isinstance(n, Instance)
+            env.filters['is_raw_data'] = lambda n: isinstance(n, RawData)
+            env.filters['is_archive_resource'] = lambda n: isinstance(
+                n, ArchiveResource)
+            env.filters['is_structure'] = lambda n: isinstance(n, Structure)
+            env.filters['is_enumeration_reference'] = lambda n: isinstance(n, EnumerationReference)
+            env.filters['is_enumeration'] = lambda n: isinstance(n, Enumeration)
+            env.filters['is_constant'] = lambda n: isinstance(n, Constant)
+            env.filters['is_namespace'] = lambda n: isinstance(n, Namespace)
+            env.filters['is_resource'] = lambda n: isinstance(n, ResourceBase)
+            env.filters['is_bound_resource'] = lambda n: isinstance(
+                n, BoundResource)
+            env.filters['is_vector'] = lambda n: isinstance(n, Vector)
+            env.filters['is_multivector'] = lambda n: isinstance(n, Multivector)
+            env.filters['is_multivector_index'] = lambda n: (isinstance(
+                n, Structure) and "_builtin.multivector" in SyntaxTree.namespace_path(n))
+            env.filters['namespaces'] = SyntaxTree.namespaces
+            env.filters['not_auto_generated'] = lambda n: [ x for x in n if not x.auto_generated]
+            self._populate_environment(env, tree)
+            self._env = env
+        return self._env
+
+    def render(self, tree: SyntaxTree) -> str:
+        """Generate the language implementation from the AST"""
+        env = self._get_environment(tree)
+        template = env.get_template(self._template)
+
+        flatdata_nodes = [n for n, _ in DfsTraversal(tree).dependency_order() if
+                          any([isinstance(n, t) for t in self.supported_nodes()])]
+        filtered_nodes = self.filter_nodes(flatdata_nodes, tree)
+        imports = self.get_import_directives(tree)
+        return template.render(nodes=filtered_nodes, tree=tree, imports=imports)
+
+
+class RaiseExtension(Extension):
+    """Nicer error formatting for jinja2"""
+
+    tags = set(['raise'])
+
+    def parse(self, parser: Parser) -> nodes.CallBlock:
+        """The first token is the line number, followed by the expression"""
+        lineno = next(parser.stream).lineno
+        message_node = parser.parse_expression()
+        return nodes.CallBlock(
+            self.call_method(name='_raise', args=[message_node], lineno=lineno), [], [], [],
+            lineno=lineno
+        )
+
+    #pylint: disable=no-self-use
+    def _raise(self, msg: str, caller: object) -> NoReturn:
+        """Helper callback."""
+        raise TemplateRuntimeError(msg)

{flatdata_generator-0.4.10 → flatdata_generator-0.4.12}/flatdata/generator/generators/cpp.py

@@ -3,31 +3,50 @@
  See the LICENSE file in the root of this project for license details.
 '''
 
+from __future__ import annotations
+
+import posixpath
+
+from jinja2 import Environment
+
+from flatdata.generator.tree.helpers.basictype import BasicType
+from flatdata.generator.tree.helpers.enumtype import EnumType
+from flatdata.generator.tree.nodes.node import Node
+from flatdata.generator.tree.nodes.references import BuiltinStructureReference, StructureReference
 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
 from flatdata.generator.tree.nodes.archive import Archive
+from flatdata.generator.tree.syntax_tree import SyntaxTree
 from . import BaseGenerator
 
 
 class CppGenerator(BaseGenerator):
     """Flatdata to C++ header file generator"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         BaseGenerator.__init__(self, "cpp/cpp.jinja2")
 
-    def supported_nodes(self):
+    def supported_nodes(self) -> list[type]:
         return [Structure, Archive, Constant, Enumeration]
 
-    def _populate_environment(self, env):
+    def filter_nodes(self, nodes: list[Node], tree: SyntaxTree) -> list[Node]:
+        if not tree.imports:
+            return nodes
+        return [n for n in nodes if tree.is_local_node(n)]
+
+    def get_import_directives(self, tree: SyntaxTree) -> list[str]:
+        return [posixpath.normpath(imp.path).replace('.flatdata', '.h') for imp in tree.imports]
+
+    def _populate_environment(self, env: Environment, tree: SyntaxTree) -> 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: BasicType | EnumType | Node) -> str:
             type_map = {
                 "bool": "bool",
                 "i8": "int8_t",
@@ -41,28 +60,28 @@ class CppGenerator(BaseGenerator):
             }
             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[BuiltinStructureReference | StructureReference]) -> 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: Field | ResourceBase, 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: ResourceBase, extra_suffix: str = "") -> str:
+            def _wrap_in_optional(declaration: str) -> str:
                 if resource.optional:
                     return "boost::optional< %s >" % declaration
                 return declaration
@@ -71,7 +90,7 @@ class CppGenerator(BaseGenerator):
 
         env.filters["archive_typedef_usage"] = _optional_typedef_usage
 
-        def _resource_provides_incremental_builder(resource):
+        def _resource_provides_incremental_builder(resource: ResourceBase) -> bool:
             assert isinstance(resource, ResourceBase)
             if isinstance(resource, Instance):
                 return False
@@ -86,7 +105,7 @@ class CppGenerator(BaseGenerator):
         env.filters[
             "resource_provides_incremental_builder"] = _resource_provides_incremental_builder
 
-        def provides_setter(resource):
+        def provides_setter(resource: ResourceBase) -> bool:
             assert isinstance(resource, ResourceBase)
             if isinstance(resource, Instance):
                 return True