Codegen dataclassess

[Daquiver1]

No description provided.

[michalgr]

We also need to emit dataclasses for the nested structs. We'll need some code to visit/iterate over all nested structs.

[michalgr]

I recommend separating struct name computation from python type computation. We need functions/classes doing the following:

1. Walking Structs to retrieve nested Structs
2. Assigning names to Structs
3. Computing types of fields given names of all the Structs involved
4. Generating code for data classes
   If possible it would be great to minimise dependencies between them.

For example I would start by writing a generator recursively walking structs, something like this:

StructLink = typing.Tuple[Struct, Field, Struct]
def nested_structs(root: Struct) -> typing.Generator[StructLink, None, None]:
    for field in root.fields:
        type = field.type
        match type:
            case Array():
                yield root, field, type.element_type
                yield from nested_structs(type.element_type)
            case TaggedUnion():
                for struct in type.cases.values():
                    yield root, field, struct
                    yield from nested_structs(struct)
            case Struct():
                yield root, field, type
                yield from nested_structs(type)

Such generator would then be a base for the algorithm assigning names to structs and algorithm generating all the dataclasses we want. For example:

def compute_struct_names(root: Struct, name: str) -> Mapping[Struct, str]:
    names = {
        root: name,
    }
    for parent, field, nested in nested_structs(root):
        type = field.type
        match field.type:
            case Struct():
                names[nested] = f"{names[parent]}{field.name.captialize()}"
            case Array():
                ...
            case TaggedUnion:
                ....
    return names


# dedicated class to make it easier to pass all the necessary state around
class StructGenerator:
    def __init__(self, root: Struct, name: str):
        self.__struct_to_name = compute_struct_names(root, name)

    def __get_python_type_for(self, struct: Struct, field: Field) -> str:
        type = field.type
        match type:
            case Struct():
                return self. __struct_to_name[type]

            case Array():
                return f"typing.List[{self.__struct_to_name[type.element_type]}]"

            case TaggedUnion():
                ...

            case _:
                return types.python_type_for(type)

    def __generate_dataclass(self, struct: Struct) -> str:
        name = self.__struct_to_name[struct]
        class_def = ...
        return dedent(class_def)

    def generate(self):
        return [
            self.__generate_dataclass(nested)
            for _, _, nested in reversed(nested_structs(self.__root))
        ] + [self.__generate_dataclass(self.__root)]

[michalgr]

Tests seem to be failing.