# Dealing with "Infinite Types" in a Value-Based Language

## The Problem

In many languages constructing `struct`s with members that, when expanded, end up having a field that refers to the struct itself by value is illegal. This makes sense because, firstly, one could never actually construct such a `struct`, if one would want to construct a literal then one would be typing an infinite amount of time. Secondly, because even if the struct could be constructed, one would have to take up an infinite amount of memory. As a practical example: a binary tree can conceptually grow to an infinite size, and such an infinite tree cannot be constructed.

And so, in low-level programming languages one would replace these with pointers (or something equivalent) in order to deal with both points. The first point is no longer true, because the pointer can be `null` (in the example: this would terminate a node in the tree, making it a leaf of the tree). And secondly the size is no longer infinite and is calculable because a pointer will always have a fixed size.

In Reowolf we have value-based semantics. To have reasonable cache coherency, quick `struct`/`union` member access, and prevent memory (de)allocation overhead we want to put as much values onto a stack-like construct. For this reason we would like to precalculate the alignment and offset of each type and its members.

Point one above still stands: if one wishes to construct a type that never terminates, then the compiler should throw an error. An example of which would be:

```pdl

// Simple truly infinite type

struct Infinite { 

    Infinite member,

}

// Infinite type of cycle length 2

struct Left { Right other }

struct Right { Left other }

// Infinite type of cycle length 3

struct A { B b }

struct B { C c }

struct C { A a }

// Etcetera

// But we can also do this using unions

union A { B(B), C(C) }

union B { A(A), C(C) }

union C { A(A), B(B) }

```

If one wishes to express a type whose value causes it to terminate somewhere, the only option in this language is to use `union`s to indicate the optionality of a certain member. For example:

```pdl

// One option, allows setting branches individually

union Option<T>{ Some(T), None }

struct U32TreeExample {

    u32 value, 

    Option<TreeExample> left,

    Option<TreeExample> right,

}

// Another option, must be a well-formed binary tree

union U32TreeLink {

    Leaf,

    Node(U32TreeLink, U32TreeLink)

}

struct U32TreeNode {

    u32 value,

    U32TreeLink link,

}

// Another kind of thing

union List<T> { 

    End,

    Entry(T, List<T>)

}

```

These are all valid types, and we should be able to express them, but naively calculating their size causes one to run into issues. 

## Onwards to an Algorithm

So far one can see that `struct`s and `union`s are the elements that might constitute an infinite type. All of the other types (user defined `enum`s and all of the builtins like `u32`, `string`, `s64`, etc.) do not have any members and have a fixed size. Whenever there is a union in the type, we might have a type that is not truly infinite, but may terminate somewhere.

Imagine a graph containing all user-defined `struct` and `union` types. The edges in this graph are directional, and indicate that one type is embedded in the other. It is important to construct this graph on a per-member basis. `struct` members may have one edge running towards it, coming from the member's type. `union`s can have multiple edges running towards it, one for each embedded type in the union member. Note that types may refer to themselves.

Having constructed this graph, one can visualise the potentially infinite types by loops in the graph. A struct is potentially infinite if one of its members is part of a loop. A union is potentially infinite if all of its members are part of a loop. A potentially infinite type is a truly infinite type if the relevant loops all contain potentially infinite types. Or, conversely: a potentially infinite type is not actually infinite if the relevant loops contain a union that is not potentially infinite.

More practically: a potentially infinite struct (implying that at least one of its members is part of a type loop) is not infinite if each of its "looped members" is part of a loop which contains a non-infinite union. Likewise, a potentially infinite union (implying that all of its members are part of a loop) is not actually infinite if, for one of its members that contains a set of loops (because a union can embed multiple types per variant), each of those loops contain a non-infinite union.

And finally, in human terms: a type is not actually infinite if, given enough time, a programmer can express a literal of that type. So one may type (using the examples above):

```pdl

auto thing = List::Entry(3, List::Entry(2, List::Entry(1, List::End)));

auto flong = U32TreeExample{

    value: 0,

    left: Option::Some(U32TreeExample{

        value: 1,

        left: Option::None

    },

    right: Option::None

}

```

But one simply cannot express:

```pdl

auto cannot_construct = A::B(B::C(C::A(A::C(C::B( /* onwards, to infinity )))));

```

Now we arrive at several conditions to end up at a concrete algorithm. Firsly we have that types whose literals are expressable should be constructable in the language. Secondly, for the performance reasons mentioned above we would like to specify the memory layout for each type. So that includes the size and alignment of the type itself, and the offset (with implicit alignment and size) of each of its members. Thirdly, because we're going to have to put pointers somewhere in the aforementioned type loops (necessarily, because we have variably sized values, we need to perform some kind of allocation somewhere, hence we need to have pointers somewhere), we need these pointers to be placed consistently throughout the code. This last point is a design decision: we could decide to have some types including pointers to members, and some types excluding pointers to members. This would then require special conversion functions implemented when two values of the same type, but with a different memory layout, are converted into one another. This on top of the fact that each of the types containing a pointer will require a constructor and a destructor. Finally, albeit this point looks ahead a bit at the implementation, we desire that subsequent compilations of the same files, but potentially in a different order, result in the same layout of each of the types.

We may observe that only unions may break up potentially infinite types. So for each loop that contains a non-infinite union we need at least one union that is implemented using some kind of pointer. There are multiple ways we can fix the byte size of the union, thereby breaking the type loop:

1. Make each instance of the union a pointer to the data in that union: both the tag and the potentially embedded values. This has the upside of being relatively simple to implement. Furthermore the union itself will just have a fixed size. The downside is that for a tag lookup we have to follow the pointer, generally causing cache misses in the case that we just want to check the tag.

2. Keep the tag in a union value, but dynamically allocate all of the contents. This way the size of a union value becomes a tag and a pointer. On 32-bit systems this is most likely fine, on 64-bit systems (which is the norm, if we're not talking about embedded computers) alignment will generally cause the union size to bloat to 16-bytes. This kind of implementation has two subcases to consider. 

    - Allocate as much memory as the maximum union variant. This way changing the union variant will not force a reallocation. Instead we can use up the allocated memory.

    - Allocate as much memory as the variant requires. This way we will not waste any memory, at the cost of having to reallocate when the variant is changed.

3. Keep the tag in the union value, with the same up- and downsides as the previous point. Then dynamically allocate the members of the variants (that is, if we have `union Foo { Bar(CyclicType, u64, u64), Qux }`, then we will just make `CyclicType` a pointer). The obvious downside is that changing variants might cause (de)allocations. And if we have multiple members that cause a loop then we need to allocate each of them. The upside is that when we're only accessing the non-pointer members that they're likely already in the cache.

There are many more tiny variants here that are not explicitly stated. I'll document my reasons for choosing the variant I think works best:

- The whole idea of breaking the type cycles is not to allocate an infinite amount of memory, so always allocating the union is naturally out of the question. Furthermore type loops will generally only occur in particular datastructures that are potentially infinite: trees, linked lists, hashmaps, etc.

- The contract when using a union is that the byte size of a union value is the size of the largest member plus the size of the tag (plus padding). So allocating the union just once, with enough size to fit all possible allocated variants seems like a good idea to me. I suspect that in most cases these unions will express something along the lines of: there is nothing, or there is nothing.

Finally, as a note: all of this type-loop checking has to be performed per monomorphization. A polymorphic type specification itself does not need to be checked for type loops.

Lastly, we have to consider the point of making sure that multiple compilations, where the AST is constructed in a different order, hence where the types are "discovered" in a different order, will result in the same types. As a rather simple solution, instead of just marking one union in the type loop as pointerlike, all of the unions in the type loops will be implemented using some kind of pointer scheme.

## Concluding on the Algorithm

As an initial conclusion:

- All non-infinite unions in type loops are implemented using dynamic allocation to break the type loops and to prevent potentially infinite types from being truly infinite.

- The tag of the union will be a non-allocated value associated with the union. Considering that most of the time these kinds of unions will represent an option-like type (there is one more entry in the linked list, there is one more node in the tree, etc.) I think it is nice to not have cache misses when checking whether a value is present, or whether it is not present.

- Considering that we cannot allocate all of the time (because then we will still end up with an infinite amount of allocated memory), but I do not currently want to implement very complicated logic in the compiler for handling memory allocations, I will initially implement the following scheme: all union variants that do not contain any types part of a type loop will be stored on the stack, contributing to the byte size of the union. All variants that do contain such types will be fully allocated on the heap in one allocation. The size of the allocated region will be the size of the largest variant that requires dynamic allocation.

## Rough Specification of the Algorithm

I might be missing some stuff here, that stuff will probably pop up while I'm implementing this:

- 

   Perform the basic pre-compilation for symbol discovery and definition discovery. This constructs the AST such that we can parse the AST to determine what fields are present on each `struct` and what variants are used in each `union`.

-

    For each type added to the type table (including monomorphs where we have all of the polymorphic variables fully specified), we will traverse all of the members and their types. For each type we will check if was already checked not to be cyclic. If it was already completely checked, then all types up until the most recently checked type cannot be cyclic (another member might still make them cyclic). If the type was not completely checked, but previously encountered in our search for loops, then all of types from the first encounter of that type are considered part of a type loop.

- 

    Note that this algorithm is recursive in the sense that for structs we need to check each member for type loops. For unions we need to check each embedded type in each variant. So when we encounter a type loop for a specific set of members, we walk back and mark each of the unions along the way as requiring allocation. If there were no such unions then we immediately return an error. We keep all of the unions that require allocation around in a list.

- 

   While we're doing the above, if we encounter a union who has a member that does not exist in a type loop then we mark it as non-infinite.

- 

   After all of the above is done, we need to check all of the unions we have encountered. Necessarily if we started with a particular type, and recursively checked all of the embedded types, then we will discover *all* type loops. If none of the unions is non-infinite, then we throw an error (which might be kind of hard, because what kind of error do we show in the case of the `union A; union B; union C;` example?). With the algorithm above, we now know that if there are type loops, that each of them contains at least one union. With the condition that there is at least one non-infinite union we now know that the type is expressable. The constructed list of unions only contains unions that were part of a type loop.

   With that knowledge, to guarantee consistent compilation, we will decide to make each union in each type loop, whether it is infinite or non-infinite, a pointerlike union.

-

   A pointerlike union's value will consist of a tag, plus reserved size (with the proper alignment) for the largest non-pointerlike union variant if it is larger than the size of a pointer on the particular machine. If it is smaller, than we just need a tag, and a pointer that is properly aligned. So the union value will have a fixed size that is not dependent on the types that were part of the type cycle. I'll call the variants that were not part of type cycles "value variants", and parts that *were* part of type cycles "pointer variants".

Then, during runtime, as an initial implementation (we could be smarter if we know the old value and know the new value, but that would take a lot of static analysis, we're not yet at that point in the compiler), we will check the tag value whether the old and new values are pointers. If the old and new variants are both pointer variants, or when they're both value variants, then we do not (re)allocate. If we go from a value variant to a pointer variant then we allocate. If we go from a pointer variant to a value variant then we deallocate.

## Some Examples of the Algorithm

I wrote these before I started writing all of the above, I'll keep it here for some concrete examples of the algorithm.

### Truly Infinite Example with Structs

```pdl

// Most simple case

struct SelfReferential{ SelfReferential field }

// Slightly more complicated case

struct DualA { DualB b }

struct DualB { DualA a }

```

In some sense we would be able to compute the sizes of these datastructures, we simply make their fields pointers. Let's assume 64 bit systems for all of these examples. For just the first case we would then have that `SelfReferential` has a size of 8 bytes. However, we always need to allocate its member `field`. So this would always take up an infinite amount of memory. We disallow this case because we would never be able to construct a literal of these kinds of datatypes.

### Truly Infinite Example with Unions

```pdl

struct S { UOne one, UTwo two }

union UOne { Struct(S), One(UOne), Two(UTwo) }

union UTwo { One(UOne), Two(UTwo) } 

```

Again, here we have a case where we can compute the sizes. We make the unions have pointerlike contents. So the unions will be 16 bytes (8 bytes for the tag and padding for pointer alignment, then an 8 byte pointer). Hence the struct will be 32 bytes. But once more we can never construct a literal and instantiating an element would always take up an infinite amount of memory.

### Slightly Ambiguous Example

With the following example we get one union which is non-infinite.

```pdl

struct SEnd { u32 some_value }

struct SMiddle {

   SEnd this_ends,

   UOne union_one,

   UTwo union_two,

}

union UOne { One(UOne), Two(UTwo), Struct(SMiddle) }

union UTwo { One(UOne), Two(UTwo), End(u32) }

```

If we draw the type graph, we get something like:

```pdl

+--------+        +---------+        +-------+        +-------+

| struct |        | struct  | <----- | union | <----- | union |

| SEnd   | -----> | SMiddle | -----> | UOne  | -----> | UTwo  |

+--------+        +---------+        +-------+        +-------+

                                      |     ^          |     ^

                                      |     |          |     |

                                      \-----/          \-----/

```

For this case we can actually always construct a literal of `SMiddle`. Viewing the literal as a tree (each node a type instance) then we can terminate the tree branches using `UTwo::End`. However, if we would just make `UTwo` pointerlike, we cannot compute the size of `UOne` (it contains a reference to itself, so would grow infinitely in size). This hints at that we should make `UOne` pointerlike as well.

### Slightly Ambiguous Example, Version 2

Not really ambiguous, but just to show that not all unions which are part of a connected type graph need to be turned into pointerlike unions.

```pdl

union Value {

    Unsigned(u64),

    Signed(s64),

    Undefined

}

struct Node {

    Value value,

    Children children

}

union Children {

    One(Node),

    Two(Node, Node),

    None

}

```

We get a cycle between `Node` and `Children`, so we would want to implement `Children` as being pointerlike. But we don't have to make `Value` pointerlike. In terms of the described algorithm: `Value` is not part of a type loop, so is not considered a candidate for being pointerlike.

### Slightly Ambigious Example, Version 3

Contains part of the type graph that is not part of a type loop. So the associated union should not be pointerlike.

```pdl

// Parts that are outside of the type loop

struct SOutside {

    UOutside next,

}

union UOutside {

    Next(SInside)

}

// Parts that are inside the type loop

struct SInside {

    UInside next,

}

union UInside {

    Next(SInside),

    NoNext,

}

```

Here `UInside` should become pointerlike, but `UOutside` should remain a normal value.

### Which Union Breaks the Cycle?

```pdl

struct S { UOne one }

union UOne { Two(UTwo), Nope }

union UTwo { Struct(S), Nope }

```

Here we see that we have a type loop to which both unions contribute. We can either lay out `UOne` as pointerlike, or `UTwo`. Both would allow us to calculate the size of the types and make the type expressable. However we need consistent compilation. For this reason and this reason only (because it is much more efficient to only lay out one of the unions as a pointer) we have to make both unions pointerlike. Perhaps in the future some other consistent metric can be applied.

// TODO: @cleanup, rigorous cleanup of dead code and silly object-oriented

//  trait impls where I deem them unfit.

use std::fmt;

use std::fmt::{Debug, Display, Formatter};

use std::ops::{Index, IndexMut};

use super::arena::{Arena, Id};

use crate::collections::StringRef;

use crate::protocol::input_source::InputSpan;

/// Helper macro that defines a type alias for a AST element ID. In this case 

/// only used to alias the `Id<T>` types.

macro_rules! define_aliased_ast_id {

    // Variant where we just defined the alias, without any indexing

    ($name:ident, $parent:ty) => {

        pub type $name = $parent;

    };

    // Variant where we define the type, and the Index and IndexMut traits

    (

        $name:ident, $parent:ty, 

        index($indexed_type:ty, $indexed_arena:ident)

    ) => {

        define_aliased_ast_id!($name, $parent);

        impl Index<$name> for Heap {

            type Output = $indexed_type;

            fn index(&self, index: $name) -> &Self::Output {

                &self.$indexed_arena[index]

            }

        }

        impl IndexMut<$name> for Heap {

            fn index_mut(&mut self, index: $name) -> &mut Self::Output {

                &mut self.$indexed_arena[index]

            }

        }

    };

    // Variant where we define type, Index(Mut) traits and an allocation function

    (

        $name:ident, $parent:ty,

        index($indexed_type:ty, $indexed_arena:ident),

        alloc($fn_name:ident)

    ) => {

        define_aliased_ast_id!($name, $parent, index($indexed_type, $indexed_arena));

        impl Heap {

            pub fn $fn_name(&mut self, f: impl FnOnce($name) -> $indexed_type) -> $name {

                self.$indexed_arena.alloc_with_id(|id| f(id))

            }

        }

    };

}

/// Helper macro that defines a wrapper type for a particular variant of an AST

/// element ID. Only used to define single-wrapping IDs.

macro_rules! define_new_ast_id {

    // Variant where we just defined the new type, without any indexing

    ($name:ident, $parent:ty) => {

        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

        pub struct $name (pub(crate) $parent);

        #[allow(dead_code)]

        impl $name {

            pub(crate) fn new_invalid() -> Self     { Self(<$parent>::new_invalid()) }

            pub(crate) fn is_invalid(&self) -> bool { self.0.is_invalid() }

            pub fn upcast(self) -> $parent          { self.0 }

        }

    };

    // Variant where we define the type, and the Index and IndexMut traits

    (

        $name:ident, $parent:ty, 

        index($indexed_type:ty, $wrapper_type:path, $indexed_arena:ident)

    ) => {

        define_new_ast_id!($name, $parent);

        impl Index<$name> for Heap {

            type Output = $indexed_type;

            fn index(&self, index: $name) -> &Self::Output {

                if let $wrapper_type(v) = &self.$indexed_arena[index.0] {

                    v

                } else {

                    unreachable!()

                }

            }

        }

        impl IndexMut<$name> for Heap {

            fn index_mut(&mut self, index: $name) -> &mut Self::Output {

                if let $wrapper_type(v) = &mut self.$indexed_arena[index.0] {

                    v

                } else {

                    unreachable!()

                }

            }

        }

    };

    // Variant where we define the type, the Index and IndexMut traits, and an allocation function

    (

        $name:ident, $parent:ty, 

        index($indexed_type:ty, $wrapper_type:path, $indexed_arena:ident),

        alloc($fn_name:ident)

    ) => {

        define_new_ast_id!($name, $parent, index($indexed_type, $wrapper_type, $indexed_arena));

        impl Heap {

            pub fn $fn_name(&mut self, f: impl FnOnce($name) -> $indexed_type) -> $name {

                $name(

                    self.$indexed_arena.alloc_with_id(|id| {

                        $wrapper_type(f($name(id)))

                    })

                )

            }

        }

    }

}

define_aliased_ast_id!(RootId, Id<Root>, index(Root, protocol_descriptions), alloc(alloc_protocol_description));

define_aliased_ast_id!(PragmaId, Id<Pragma>, index(Pragma, pragmas), alloc(alloc_pragma));

define_aliased_ast_id!(ImportId, Id<Import>, index(Import, imports), alloc(alloc_import));

define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables), alloc(alloc_variable));

define_aliased_ast_id!(DefinitionId, Id<Definition>, index(Definition, definitions));

define_new_ast_id!(StructDefinitionId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));

define_new_ast_id!(EnumDefinitionId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));

define_new_ast_id!(UnionDefinitionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));

define_new_ast_id!(ComponentDefinitionId, DefinitionId, index(ComponentDefinition, Definition::Component, definitions), alloc(alloc_component_definition));

define_new_ast_id!(FunctionDefinitionId, DefinitionId, index(FunctionDefinition, Definition::Function, definitions), alloc(alloc_function_definition));

define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));

define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));

define_new_ast_id!(EndBlockStatementId, StatementId, index(EndBlockStatement, Statement::EndBlock, statements), alloc(alloc_end_block_statement));

define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements), alloc(alloc_local_statement));

define_new_ast_id!(MemoryStatementId, LocalStatementId);

define_new_ast_id!(ChannelStatementId, LocalStatementId);

define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));

define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));

define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));

define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));

define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));

define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));

define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));

define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));

define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));

define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));

define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));

define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));

define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));

define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));

define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));

define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));

define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));

define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));

define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));

define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));

define_new_ast_id!(SlicingExpressionId, ExpressionId, index(SlicingExpression, Expression::Slicing, expressions), alloc(alloc_slicing_expression));

define_new_ast_id!(SelectExpressionId, ExpressionId, index(SelectExpression, Expression::Select, expressions), alloc(alloc_select_expression));

define_new_ast_id!(LiteralExpressionId, ExpressionId, index(LiteralExpression, Expression::Literal, expressions), alloc(alloc_literal_expression));

define_new_ast_id!(CastExpressionId, ExpressionId, index(CastExpression, Expression::Cast, expressions), alloc(alloc_cast_expression));

define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Expression::Call, expressions), alloc(alloc_call_expression));

define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));

#[derive(Debug)]

pub struct Heap {

    // Root arena, contains the entry point for different modules. Each root

    // contains lists of IDs that correspond to the other arenas.

    pub(crate) protocol_descriptions: Arena<Root>,

    // Contents of a file, these are the elements the `Root` elements refer to

    pragmas: Arena<Pragma>,

    pub(crate) imports: Arena<Import>,

    pub(crate) variables: Arena<Variable>,

    pub(crate) definitions: Arena<Definition>,

    pub(crate) statements: Arena<Statement>,

    pub(crate) expressions: Arena<Expression>,

}

impl Heap {

    pub fn new() -> Heap {

        Heap {

            // string_alloc: StringAllocator::new(),

            protocol_descriptions: Arena::new(),

            pragmas: Arena::new(),

            imports: Arena::new(),

            variables: Arena::new(),

            definitions: Arena::new(),

            statements: Arena::new(),

            expressions: Arena::new(),

        }

    }

    pub fn alloc_memory_statement(

        &mut self,

        f: impl FnOnce(MemoryStatementId) -> MemoryStatement,

    ) -> MemoryStatementId {

        MemoryStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {

            Statement::Local(LocalStatement::Memory(

                f(MemoryStatementId(LocalStatementId(id)))

            ))

        })))

    }

    pub fn alloc_channel_statement(

        &mut self,

        f: impl FnOnce(ChannelStatementId) -> ChannelStatement,

    ) -> ChannelStatementId {

        ChannelStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {

            Statement::Local(LocalStatement::Channel(

                f(ChannelStatementId(LocalStatementId(id)))

            ))

        })))

    }

}

impl Index<MemoryStatementId> for Heap {

    type Output = MemoryStatement;

    fn index(&self, index: MemoryStatementId) -> &Self::Output {

        &self.statements[index.0.0].as_memory()

    }

}

impl Index<ChannelStatementId> for Heap {

    type Output = ChannelStatement;

    fn index(&self, index: ChannelStatementId) -> &Self::Output {

        &self.statements[index.0.0].as_channel()

    }

}

#[derive(Debug, Clone)]

pub struct Root {

    pub this: RootId,

    // Phase 1: parser

    // pub position: InputPosition,

    pub pragmas: Vec<PragmaId>,

    pub imports: Vec<ImportId>,

    pub definitions: Vec<DefinitionId>,

}

impl Root {

    pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {

        for &def in self.definitions.iter() {

            if h[def].identifier().value.as_bytes() == id {

                return Some(def);

            }

        }

        None

    }

}

#[derive(Debug, Clone)]

pub enum Pragma {

    Version(PragmaVersion),

    Module(PragmaModule),

}

impl Pragma {

    pub(crate) fn as_module(&self) -> &PragmaModule {

        match self {

            Pragma::Module(pragma) => pragma,

            _ => unreachable!("Tried to obtain {:?} as PragmaModule", self),

        }

    }

}

#[derive(Debug, Clone)]

pub struct PragmaVersion {

    pub this: PragmaId,

    // Phase 1: parser

    pub span: InputSpan, // of full pragma

    pub version: u64,

}

#[derive(Debug, Clone)]

pub struct PragmaModule {

    pub this: PragmaId,

    // Phase 1: parser

    pub span: InputSpan, // of full pragma

    pub value: Identifier,

}

#[derive(Debug, Clone)]

pub enum Import {

    Module(ImportModule),

    Symbols(ImportSymbols)

}

impl Import {

    pub(crate) fn span(&self) -> InputSpan {

        match self {

            Import::Module(v) => v.span,

            Import::Symbols(v) => v.span,

        }

    }

    pub(crate) fn as_module(&self) -> &ImportModule {

        match self {

            Import::Module(m) => m,

            _ => unreachable!("Unable to cast 'Import' to 'ImportModule'")

        }

    }

    pub(crate) fn as_symbols(&self) -> &ImportSymbols {

        match self {

            Import::Symbols(m) => m,

            _ => unreachable!("Unable to cast 'Import' to 'ImportSymbols'")

        }

    }

    pub(crate) fn as_symbols_mut(&mut self) -> &mut ImportSymbols {

        match self {

            Import::Symbols(m) => m,

            _ => unreachable!("Unable to cast 'Import' to 'ImportSymbols'")

        }

    }

}

#[derive(Debug, Clone)]

pub struct ImportModule {

    pub this: ImportId,

    // Phase 1: parser

    pub span: InputSpan,

    pub module: Identifier,

    pub alias: Identifier,

    pub module_id: RootId,

}

#[derive(Debug, Clone)]

pub struct AliasedSymbol {

    pub name: Identifier,

    pub alias: Option<Identifier>,

    pub definition_id: DefinitionId,

}

#[derive(Debug, Clone)]

pub struct ImportSymbols {

    pub this: ImportId,

    // Phase 1: parser

    pub span: InputSpan,

    pub module: Identifier,

    pub module_id: RootId,

    pub symbols: Vec<AliasedSymbol>,

}

#[derive(Debug, Clone)]

pub struct Identifier {

    pub span: InputSpan,

    pub value: StringRef<'static>,

}

impl PartialEq for Identifier {

    fn eq(&self, other: &Self) -> bool {

        return self.value == other.value

    }

}

impl Display for Identifier {

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

        write!(f, "{}", self.value.as_str())

    }

}

#[derive(Debug, Clone, PartialEq, Eq)]

pub enum ParserTypeVariant {

    // Special builtin, only usable by the compiler and not constructable by the

    // programmer

    Void,

    InputOrOutput,

    ArrayLike,

    IntegerLike,

    // Basic builtin

    Message,

    Bool,

    UInt8, UInt16, UInt32, UInt64,

    SInt8, SInt16, SInt32, SInt64,

    Character, String,

    // Literals (need to get concrete builtin type during typechecking)

    IntegerLiteral,

    // Marker for inference

    Inferred,

    // Builtins expecting one subsequent type

    Array,

    Input,

    Output,

    // User-defined types

    PolymorphicArgument(DefinitionId, u32), // u32 = index into polymorphic variables

    Definition(DefinitionId, u32), // u32 = number of subsequent types in the type tree.

}

impl ParserTypeVariant {

    pub(crate) fn num_embedded(&self) -> usize {

        use ParserTypeVariant::*;

        match self {

            Void | IntegerLike |

            Message | Bool |

            UInt8 | UInt16 | UInt32 | UInt64 |

            SInt8 | SInt16 | SInt32 | SInt64 |

            Character | String | IntegerLiteral |

            Inferred | PolymorphicArgument(_, _) =>

                0,

            ArrayLike | InputOrOutput | Array | Input | Output =>

                1,

            Definition(_, num) => *num as usize,

        }

    }

}

/// ParserTypeElement is an element of the type tree. An element may be

/// implicit, meaning that the user didn't specify the type, but it was set by

/// the compiler.

#[derive(Debug, Clone)]

pub struct ParserTypeElement {

    // TODO: @Fix span

    pub element_span: InputSpan, // span of this element, not including the child types

    pub variant: ParserTypeVariant,

}

/// ParserType is a specification of a type during the parsing phase and initial

/// linker/validator phase of the compilation process. These types may be

/// (partially) inferred or represent literals (e.g. a integer whose bytesize is

/// not yet determined).

///

/// Its contents are the depth-first serialization of the type tree. Each node

/// is a type that may accept polymorphic arguments. The polymorphic arguments

/// are then the children of the node.

#[derive(Debug, Clone)]

pub struct ParserType {

    pub elements: Vec<ParserTypeElement>,

    pub full_span: InputSpan,

}

impl ParserType {

    pub(crate) fn iter_embedded(&self, parent_idx: usize) -> ParserTypeIter {

        ParserTypeIter::new(&self.elements, parent_idx)

    }

}

/// Iterator over the embedded elements of a specific element.

pub struct ParserTypeIter<'a> {

    pub elements: &'a [ParserTypeElement],

    pub cur_embedded_idx: usize,

}

impl<'a> ParserTypeIter<'a> {

    fn new(elements: &'a [ParserTypeElement], parent_idx: usize) -> Self {

        debug_assert!(parent_idx < elements.len(), "parent index exceeds number of elements in ParserType");

        if elements[0].variant.num_embedded() == 0 {

            // Parent element does not have any embedded types, place

            // `cur_embedded_idx` at end so we will always return `None`

            Self{ elements, cur_embedded_idx: elements.len() }

        } else {

            // Parent element has an embedded type

            Self{ elements, cur_embedded_idx: parent_idx + 1 }

        }

    }

}

impl<'a> Iterator for ParserTypeIter<'a> {

    type Item = &'a [ParserTypeElement];

    fn next(&mut self) -> Option<Self::Item> {

        let elements_len = self.elements.len();

        if self.cur_embedded_idx >= elements_len {

            return None;

        }

        // Seek to the end of the subtree

        let mut depth = 1;

        let start_element = self.cur_embedded_idx;

        while self.cur_embedded_idx < elements_len {

            let cur_element = &self.elements[self.cur_embedded_idx];

            let depth_change = cur_element.variant.num_embedded() as i32 - 1;

            depth += depth_change;

            debug_assert!(depth >= 0, "illegally constructed ParserType: {:?}", self.elements);

            self.cur_embedded_idx += 1;

            if depth == 0 {

                break;

            }

        }

        debug_assert!(depth == 0, "illegally constructed ParserType: {:?}", self.elements);

        return Some(&self.elements[start_element..self.cur_embedded_idx]);

    }

}

/// ConcreteType is the representation of a type after the type inference and

/// checker is finished. These are fully typed.

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

pub enum ConcreteTypePart {

    // Special types (cannot be explicitly constructed by the programmer)

    Void,

    // Builtin types without nested types

    Message,

    Bool,

    UInt8, UInt16, UInt32, UInt64,

    SInt8, SInt16, SInt32, SInt64,

    Character, String,

    // Builtin types with one nested type

    Array,

    Slice,

    Input,

    Output,

    // User defined type with any number of nested types

    Instance(DefinitionId, u32),

}

#[derive(Debug, Clone, Eq, PartialEq)]

pub struct ConcreteType {

    pub(crate) parts: Vec<ConcreteTypePart>

}

impl Default for ConcreteType {

    fn default() -> Self {

        Self{ parts: Vec::new() }

    }

}

#[derive(Debug, Clone, Copy)]

pub enum Scope {

    Definition(DefinitionId),

    Regular(BlockStatementId),

    Synchronous((SynchronousStatementId, BlockStatementId)),

}

impl Scope {

    pub fn is_block(&self) -> bool {

        match &self {

            Scope::Definition(_) => false,

            Scope::Regular(_) => true,

            Scope::Synchronous(_) => true,

        }

    }

    pub fn to_block(&self) -> BlockStatementId {

        match &self {

            Scope::Regular(id) => *id,

            Scope::Synchronous((_, id)) => *id,

            _ => panic!("unable to get BlockStatement from Scope")

        }

    }

}

/// `ScopeNode` is a helper that links scopes in two directions. It doesn't

/// actually contain any information associated with the scope, this may be

/// found on the AST elements that `Scope` points to.

#[derive(Debug, Clone)]

pub struct ScopeNode {

    pub parent: Scope,

    pub nested: Vec<Scope>,

}

impl ScopeNode {

    pub(crate) fn new_invalid() -> Self {

        ScopeNode{

            parent: Scope::Definition(DefinitionId::new_invalid()),

            nested: Vec::new(),

        }

    }

}

#[derive(Debug, Clone, PartialEq, Eq)]

pub enum VariableKind {

    Parameter,      // in parameter list of function/component

    Local,          // declared in function/component body

    Binding,        // may be bound to in a binding expression (determined in validator/linker)

}

#[derive(Debug, Clone)]

pub struct Variable {

    pub this: VariableId,

    // Parsing

    pub kind: VariableKind,

    pub parser_type: ParserType,

    pub identifier: Identifier,

    // Validator/linker

    pub relative_pos_in_block: u32,

    pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

}

#[derive(Debug, Clone)]

pub enum Definition {

    Struct(StructDefinition),

    Enum(EnumDefinition),

    Union(UnionDefinition),

    Component(ComponentDefinition),

    Function(FunctionDefinition),

}

impl Definition {

    pub fn is_struct(&self) -> bool {

        match self {

            Definition::Struct(_) => true,

            _ => false

        }

    }

    pub(crate) fn as_struct(&self) -> &StructDefinition {

        match self {