Exclude unneeded parameterized types from generation

[akoptelov]

Currently generated types closely follow OCaml structure, i.e. there's a separate type definition for polymorphic types and there's one for each type to be able to encode version. That makes much harder to understand data structure.

Ideally there should be a type in Rust corresponding only to non-polymorphic types, and Versioned definitions only for limited number of types (like top-level types).

• [x] name-placeholder/bin-prot-rs#1

[akoptelov]

For example, consider the following definition. Note also that each of MinaBasePendingCoinbaseMerkleTreeVersionedStableV2 and MinaBasePendingCoinbaseStackIdStableV1 has similar indirection.

pub struct MinaBasePendingCoinbaseStableV2(
    pub  MinaBasePendingCoinbaseStableV2Poly<
        MinaBasePendingCoinbaseMerkleTreeVersionedStableV2,
        MinaBasePendingCoinbaseStackIdStableV1,
    >,
);

pub struct MinaBasePendingCoinbaseStableV2Poly<Tree, StackId> {
    pub tree: Tree,
    pub pos_list: Vec<StackId>,
    pub new_pos: StackId,
}

This should be more succinct and comprehensible:

pub struct MinaBasePendingCoinbaseStableV2 {
    pub tree: MinaBasePendingCoinbaseMerkleTreeVersionedStableV2,
    pub pos_list: Vec<MinaBasePendingCoinbaseStackIdStableV1>,
    pub new_pos: MinaBasePendingCoinbaseStackIdStableV1,
}

[akoptelov]

An update on this task.

These are the main issues I'm struggling with:

• Duplicate types. If the same type expression is referenced from multiple places (e.g. fields), it is better to have it generated only once. It is non-trivial for generic case (e.g. two fields reference the same type), but it should work fine for named types -- we do not generate the same top app with the same name twice.
• Type variables. Currently we have a venv, mapping from type var name to a substitution expression. The issue is that that substitution can have type variables as well, and their names can (and very often do) collide with already existing ones. The current solution is to maintain a stack of such venvs, and map each type variable to a pair of the substitution expression and the index of the venv it should use.
• Recursive types. Currently the only supported case is when the recursive type reference is exactly the same as the context type (quite usual case for Rust recursive types). There is only one type that does not follow this pattern -- recursive reference uses tuples of its parameters. This case should be handled properly, with error reported and probably type generated but commented out, to make it easier to implement it manually.
• Non-poly types. There are polymorphic types (in proof subsystem) that do not have that do not have corresponding concrete type instance. Currently they will be instantiated to concrete Rust types anyway, but in the future we might want to have them as an exception to type variables substitution. Also other types might be considered as that exception, like @dkuehr noticed.