- `if`, `while`, `synchronous`, `function`, `primitive` and `composite` body statements, if not yet a block, are all converted into a block for simpler parsing/compiling.

# Thinkings: Type System

## Basic Types

Builtin primitive types:

- Boolean: `bool`

- Unsigned integers: `u8`, `u16`, `u32`, `u64`

- Signed integers: `i8`, `i16`, `i32`, `i64`

- Decimal numbers: `f32`, `f64`

- Message-based: `in<T>`, `out<T>`, `msg`

Builtin compound types:

- Array: `array<T>`

User-specified types (excluding polymorphism for now):

- Connectors: `primitive`, `composite`

- Functions: `func`

- Enums: `enum`

- Unions: `enum`

- Structs: `struct`

## Polymorphic Type Definitions

Various types may be polymorphic. We will exclude builtin polymorphs from the following considerations (i.e. `in`, `out` and `array`, and their associated functions).

Connectors, functions, enums, unions and structs may all be polymorphic. We'll use the C++/rust/Java syntax for specifying polymorphic types:

```pdl

primitive fifo<T>(in<T> i, out<T> o) {

    // impl

}

T pick_one_of_two<T>(T one, T two) {

    // impl

}

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

enum Result<T, E>{ Ok(T), Err(E) }

struct Pair<T> { T first, T second }

```

This means that during the initial validation/linker phase all of the types may have polymorphic arguments. These polyargs have just an identifier, we can only determine the concrete type when we encounter it in another body where we either defer the type or where the user has explicitly instantiated the type.

For now we will use the C++-like trait/interfaceless polymorphism: once we know all of the polymorphic arguments we will try to monomorphize the type and check whether or not all calls make sense. This in itself is a recursive operation: inside the polymorph we may use other polymorphic types.

## Polymorphic Type Usage

Within functions and connectors we may employ polymorphic types. The specification of the polymorphic arguments is not required if they can be inferred. Polymorphic arguments may be partially specified by using somekind of throwaway `_` or `auto` type. When we are monomorphizing a type we must be able to fully determine all of the polymorphic arguments, if we can't then we throw a compiler error.

## Conclusions

- 

    Type definitions may contain polymorphic arguments. These are simple identifiers. The polymorphic arguments are embedded in definitions, they are erased after type inference on the type's use (e.g. function call or struct instantiation) has finished.

- 

    While instantiating polymorphic types (e.g. `T something = call_a_func(3, 5)` or the inferred variant `let something = call_a_func(3, 5)`) we actually need to resolve these types. This implies:

    - Memory declarations will have their type embedded within the memory declaration itself. If we do not know the type yet, or only partially know the type, then we need to mark the type as being inferred.

    - Expressions will have their type inferred from the constraints the expression imposes on its arguments, and the types of the arguments themselves. Within an expression tree type information may flow from the root towards the leaves or from the leaves towards the root.

    This implies that type information in the AST must be fully specified. If the type information is not yet fully known then it must be embedded in some kind of datastructure that is used for type inference.

-

    A function definition with polyargs seems to behave a bit differently: During the initial definition parsing we may want to make sure that each type in the definition either resolves to a concrete type (optionally with polymorphic arguments) or to one of the polyargs. This would also provide information to the type inference algorithm.

## Conclusions - Parsing

During parsing we want to embed all of the information the programmer has provided to the compiler in the AST. So polyargs go inside type definitions, types that are supposed to be inferred are embedded in the AST, types that depend on polyargs also go into the AST. So we may have:

- Partially concrete types with embedded inferred types (e.g. `let[] list_of_things` is an `Array<auto>` or `Result<auto> thing = Result::Ok(5)` or `let thing = Result::Ok(5)`).

- Direct references to polyarg types (e.g. `T list_of_things` or `Result<T> thing = ...` or `T[][] array_of_arrays_yes_sir` and `Tuple2<T, T> = construct_a_thing()`)

- Fully inferred types (e.g. `auto thing = 5` or `auto result = call_a_thing()`)

- Completely specified types.

## Conclusions - Type Inference

During type inference and typechecking we need to determine all concrete types. So we will arrive at a fully specified type: every polymorphic type will have its polyargs specified. Likewise every inferred type will be fully specified as well.

All of this hints at having to specify two classes of types: `ParserType` and a `Type`. The `ParserType` can be:

- A builtin type (with embedded `ParserType`s where appropriate)

- An inferred type

- A polyarg type

- A symbolic type (with embedded `ParsedType`s where appropriate)

While the final `Type` can be:

- A builtin type (with embedded types where appropriate)

- A known user-defined type (with embedded types where appropriate)

Note that we cannot typecheck polymorphic connectors and functions until we monomorphize them.

define_aliased_ast_id!(ParserTypeId, Id<ParserType>);

    pub(crate) parser_types: Arena<ParserType>,

            parser_types: Arena::new(),

    pub fn alloc_parser_type(

        f: impl FnOnce(ParserTypeId) -> ParserType,

    ) -> ParserTypeId {

        self.parser_types.alloc_with_id(|id| f(id))

impl Index<ParserTypeId> for Heap {

    type Output = ParserType;

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

        &self.parser_types[index.index]

    }

}

/// TODO: @cleanup Maybe handle this differently, preallocate in heap? The

///     reason I'm handling it like this now is so we don't allocate types in

///     the `Arena` structure if they're the common types defined here.

pub enum ParserTypeVariant {

    // Basic builtin

    Message,

    Bool,

    Byte,

    Short,

    Int,

    Long,

    String,

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

    IntegerLiteral,

    Inferred,

    // Complex builtins

    Array(ParserTypeId), // array of a type

    Input(ParserTypeId), // typed input endpoint of a channel

    Output(ParserTypeId), // typed output endpoint of a channel

    Symbolic(SymbolicParserType), // symbolic type (definition or polyarg)

}

impl ParserTypeVariant {

    pub(crate) fn supports_polymorphic_args(&self) -> bool {

        use ParserTypeVariant::*;

        match ParserTypeVariant {

            Message | Bool | Byte | Short | Int | Long | String | IntegerLiteral | Inferred => false,

            _ => true

        }

    }

}

/// 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).

#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]

pub struct ParserType {

    pub this: ParserTypeId,

    pub pos: InputPosition,

    pub variant: ParserTypeVariant,

}

/// SymbolicParserType is the specification of a symbolic type. During the

/// parsing phase we will only store the identifier of the type. During the

/// validation phase we will determine whether it refers to a user-defined type,

/// or a polymorphic argument. After the validation phase it may still be the

/// case that the resulting `variant` will not pass the typechecker.

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct SymbolicParserType {

    // Phase 1: parser

    pub identifier: NamespacedIdentifier,

    /// The user-specified polymorphic arguments. Zero-length implies that the

    /// user did not specify any of them, and they're either not needed or all

    /// need to be inferred. Otherwise the number of polymorphic arguments must

    /// match those of the corresponding definition

    pub poly_args: Vec<ParserTypeId>,

    // Phase 2: validation/linking

    pub variant: Option<SymbolicParserTypeVariant>

}

/// Specifies whether the symbolic type points to an actual user-defined type,

/// or whether it points to a polymorphic argument within the definition (e.g.

/// a defined variable `T var` within a function `int func<T>()`

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub enum SymbolicParserTypeVariant {

    Definition(DefinitionId),

    PolyArg((DefinitionId, u32)), // index of polyarg in the definition

}

    pub parser_type: ParserTypeId,

    pub parser_type: ParserTypeId,

    pub parser_type: ParserTypeId,

    pub poly_vars: Vec<Identifier>,

    Type(ParserTypeId),

    pub poly_vars: Vec<Identifier>,

    pub poly_vars: Vec<Identifier>,

    pub return_type: ParserTypeId,

    pub poly_vars: Vec<Identifier>,

/// ChannelStatement is the declaration of an input and output port associated

/// with the same channel. Note that the polarity of the ports are from the

/// point of view of the component. So an output port is something that a

/// component uses to send data over (i.e. it is the "input end" of the

/// channel), and vice versa.

            || self.has_keyword(b"auto")

    /// Consumes a type definition. When called the input position should be at

    /// the type specification. When done the input position will be at the end

    /// of the type specifications (hence may be at whitespace).

    fn consume_type2(&mut self, h: &mut Heap, allow_inference: bool) -> Result<ParserTypeId, ParseError2> {

        // Small helper function to convert in/out polymorphic arguments

        let reduce_port_poly_args = |

            heap: &mut Heap,

            port_pos: &InputPosition,

            args: Vec<ParserTypeId>,

        | {

            match args.len() {

                0 => Ok(h.alloc_parser_type(|this| ParserType{

                        this,

                        pos: port_pos.clone(),

                        variant: ParserTypeVariant::Inferred

                })),

                1 => Ok(args[0]),

                _ => Err(())

            }

        };

        // Consume the type

        let pos = self.source.pos();

        let parser_type_variant = if self.has_keyword(b"msg") {

            self.consume_keyword(b"msg");

            ParserTypeVariant::Message

        } else if self.has_keyword(b"boolean") {

            self.consume_keyword(b"boolean");

            ParserTypeVariant::Bool

        } else if self.has_keyword(b"byte") {

            self.consume_keyword(b"byte");

            ParserTypeVariant::Byte

        } else if self.has_keyword(b"short") {

            self.consume_keyword(b"short");

            ParserTypeVariant::Short

        } else if self.has_keyword(b"int") {

            self.consume_keyword(b"int");

            ParserTypeVariant::Int

        } else if self.has_keyword(b"long") {

            self.consume_keyword(b"long");

            ParserTypeVariant::Long

        } else if self.has_keyword(b"str") {

            self.consume_keyword(b"str");

            ParserTypeVariant::String

        } else if self.has_keyword(b"auto") {

            if !allow_inference {

                return Err(ParseError2::new_error(

                        &self.source, pos,

                        "Type inference is not allowed here"

                ));

            }

            self.consume_keyword(b"auto");

            ParserTypeVariant::Inferred

        } else if self.has_keyword(b"in") {

            // TODO: @cleanup: not particularly neat to have this special case

            //  where we enforce polyargs in the parser-phase

            self.consume_keyword(b"in");

            let poly_args = self.consume_polymorphic_args(h, allow_inference)?;

            let poly_arg = reduce_port_poly_args(h, &pos, poly_args)

                .map_err(|| ParseError2::new_error(

                    &self.source, pos, "'in' type only accepts up to 1 polymorphic argument"

                ))?;

            ParserTypeVariant::Input(poly_arg)

        } else if self.has_keyword(b"out") {

            self.consume_keyword(b"out");

            let poly_args = self.consume_polymorphic_args(h, allow_inference)?;

            let poly_arg = reduce_port_poly_args(h, &pos, poly_args)

                .map_err(|| ParseError2::new_error(

                    &self.source, pos, "'out' type only accepts up to 1 polymorphic argument"

                ))?;

            ParserTypeVariant::Output(poly_arg)

        } else {

            // Must be a symbolic type

            let identifier = self.consume_namespaced_identifier()?;

            let poly_args = self.consume_polymorphic_args(h, allow_inference)?;

            ParserTypeVariant::Symbolic(SymbolicParserType{identifier, poly_args, variant: None})

        };

        // If the type was a basic type (not supporting polymorphic type

        // arguments), then we make sure the user did not specify any of them.

        let mut backup_pos = self.source.pos();

        if !parser_type.supports_polymorphic_args() {

            self.consume_whitespace(false)?;

            if let Some(b'<') = self.source.next() {

                return Err(ParseError2::new_error(

                    &self.source, self.source.pos(),

                    "This type does not allow polymorphic arguments"

                ));

            }

            self.source.seek(backup_pos);

        }

        let mut parser_type_id = h.alloc_parser_type(|this| ParserType{

            this, pos, variant: parser_type_variant

        });

        // If we're dealing with arrays, then we need to wrap the currently

        // parsed type in array types

        self.consume_whitespace(false)?;

        while let Some(b'[') = self.source.next() {

            let pos = self.source.pos();

            self.source.consume();

            self.consume_whitespace(false)?;

            if let Some(b']') = self.source.next() {

                // Type is wrapped in an array

                self.source.consume();

                parser_type_id = h.alloc_parser_type(|this| ParserType{

                    this, pos, variant: ParserTypeVariant::Array(parser_type_id)

                });

                backup_pos = self.source.pos();

                // In case we're dealing with another array

                self.consume_whitespace(false)?;

            } else {

                return Err(ParseError2::new_error(

                    &self.source, pos,

                    "Expected a closing ']'"

                ));

            }

        }

        self.source.seek(backup_pos);

        Ok(parser_type_id)

    }

    /// Consumes polymorphic arguments and its delimiters if specified. The

    /// input position may be at whitespace. If polyargs are present then the

    /// whitespace and the args are consumed and the input position will be

    /// placed after the polyarg list. If polyargs are not present then the

    /// input position will remain unmodified and an empty vector will be

    /// returned.

    ///

    /// Polymorphic arguments represent the specification of the parametric

    /// types of a polymorphic type: they specify the value of the polymorphic

    /// type's polymorphic variables.

    fn consume_polymorphic_args(&mut self, h: &mut Heap, allow_inference: bool) -> Result<Vec<ParserTypeId>, ParseError2> {

        let backup_pos = self.source.pos();

        self.consume_whitespace(false)?;

        if let Some(b'<') = self.source.next() {

            // Has polymorphic args, at least one type must be specified

            self.source.consume();

            self.consume_whitespace(false)?;

            let mut poly_args = Vec::new();

            loop {

                // TODO: @cleanup, remove the no_more_types var

                poly_args.push(self.consume_type2(h, allow_inference)?);

                self.consume_whitespace(false)?;

                let has_comma = self.source.next() == Some(b',');

                if has_comma {

                    // We might not actually be getting more types when the

                    // comma is at the end of the line, and we get a closing

                    // angular bracket on the next line.

                    self.source.consume();

                    self.consume_whitespace(false)?;

                }

                if let Some(b'>') = self.source.next() {

                    self.source.consume();

                    break;

                } else if !has_comma {

                    return Err(ParseError2::new_error(

                        &self.source, self.source.pos(),

                        "Expected the end of the polymorphic argument list"

                    ))

                }

            }

            Ok(poly_args)

        } else {

            // No polymorphic args

            self.source.seek(backup_pos);

            Ok(vec!())

        }

    }

    /// Consumes polymorphic variables. These are identifiers that are used

    /// within polymorphic types. The input position may be at whitespace. If

    /// polymorphic variables are present then the whitespace, wrapping

    /// delimiters and the polymorphic variables are consumed. Otherwise the

    /// input position will stay where it is. If no polymorphic variables are

    /// present then an empty vector will be returned.

    fn consume_polymorphic_vars(&mut self) -> Result<Vec<Identifier>, ParseError2> {

        let backup_pos = self.source.pos();

        self.consume_whitespace(false)?;

        if let Some(b'<') = self.source.next() {

            // Found the opening delimiter, we want at least one polyvar

            self.source.consume();

            self.consume_whitespace(false)?;

            let mut poly_vars = Vec::new();

            loop {

                poly_vars.push(self.consume_identifier()?);

                self.consume_whitespace(false)?;

                let has_comma = self.source.next() == Some(b',');

                if has_comma {

                    // We may get another variable

                    self.source.consume();

                    self.consume_whitespace(false)?;

                }

                if let Some(b'>') = self.source.next() {

                    self.source.consume();

                    break;

                } else if !has_comma {

                    return Err(ParseError2::new_error(

                        &self.source, self.source.pos(),

                        "Expected the end of the polymorphic variable list"

                    ))

                }

            }

            Ok(poly_vars)

        } else {

            // No polymorphic args

            self.source.seek(backup_pos);

            Ok(vec!())

        }

    }

        } else if self.has_keyword(b"auto") {

            return Err(self.error_at_pos("inferred types using 'auto' are reserved, but not yet implemented"));

        let parser_type = self.consume_type2(h, false)?;

        let position = self.source.pos();

            h.alloc_parameter(|this| Parameter { this, position, parser_type, identifier });

        // Consume channel statement and polymorphic argument if specified

        let poly_args = self.consume_polymorphic_args(h, true)?;

        let poly_arg_id = match poly_args.len() {

            0 => h.alloc_parser_type(|this| ParserType{

                this, pos: position.clone(), variant: ParserTypeVariant::Inferred,

            }),

            1 => poly_args[0],

            _ => return Err(ParseError2::new_error(

                &self.source, self.source.pos(),

                "port construction using 'channel' accepts up to 1 polymorphic argument"

            ))

        };

        // Consume the output port

        let out_parser_type = h.alloc_parser_type(|this| ParserType{

            this, pos: position.clone(), variant: ParserTypeVariant::Output(poly_arg_id)

        });

        let out_identifier = self.consume_identifier()?;

        // Consume the "->" syntax

        // Consume the input port

        // TODO: Unsure about this, both ports refer to the same ParserType, is this ok?

        let in_parser_type = h.alloc_parser_type(|this| ParserType{

            this, pos: position.clone(), variant: ParserTypeVariant::Output(poly_arg_id)

        });

        let in_identifier = self.consume_identifier()?;

        let out_port = h.alloc_local(|this| Local {

            parser_type: out_parser_type,

            identifier: out_identifier,

        let in_port = h.alloc_local(|this| Local {

            parser_type: in_parser_type,

            identifier: in_identifier,

            from: out_port,

            to: in_port,

        let parser_type = self.consume_type2(h, true)?;

            parser_type,

        // Parse "struct" keyword, optional polyvars and its identifier

        let poly_vars = self.consume_polymorphic_vars()?;

            let field_parser_type = self.consume_type2(h, false)?;

                parser_type: field_parser_type,

            poly_vars,

        // Parse "enum" keyword, optional polyvars and its identifier

        let poly_vars = self.consume_polymorphic_vars()?;