Slices an array or a string (e.g. `some_array[5..calculate_the_end()]`). The beginning and ending indices must always be of **equal** `usize`/`isize` integer type. The subject must always be of type `Array<T>` or string, the return type is of the same type as the subject.

- **select expression**:

    Selects a member from a struct (e.g. `some_struct.some_field`). This expression can only be evaluated if we know the type of the subject (which must be a struct). If the field exists on that struct then we may determine the return type to be the type of that field.

- **array expression**:

    Constructs an array by explicitly specifying the members of that array. Lets assume for now that you cannot specify a string in this silly fashion. Then all of the array elements must have the same type `T`, and the result type of the expression is `Array<T>`.

- **call expression**: 

    Calls a particular function (e.g. `some_function<some_type>(some_arg)`). Non-polymorphic function arguments imply that the argument must be of the type of the argument. A non-polymorphic return type fixes the output type of the expression.

    In the polymorphic case the inference works the other way around: once we know the output type of the expression that is used as a polymorphic variable, then we can fix that particular polymorphic argument and feed that information to all places where that polymorphic argument is used.

    The same is true for the return type: if the return type of the call is polymorphic then the place where this return type is used determines the type of the polymorphic argument.

- **constant expression**: *This requires a lot of rework at some point.*

    A constant expression contains a literal of a specific type. Hence the output type of the literal is the type of the literal itself. In case of literal `struct`, `enum` and `union` instances the output type is that exact datatype.

    For the embedded types we have two cases: if the embedded type is not polymorphic and some expression is used at that position, then the embedded type must match the output type of the expression. If the embedded type is polymorphic then the output type of the expression determines the polymorphic argument. 

    In case of `string` literals the output type is also a `string`. However, in the case of integer literals we can only determine that the output type is some integer, the place where the literal is employed determines the integer type. It is valid to use this for byteshifting, but also for operating on floating-point types. In the case of decimal literals we can use these for operations on floating point types. But again: whether it is a `float` or a `double` depends on the place where the literal is used.

- **variable expression**:

    Refers to some variable declared somewhere. Hence the return type is the same as the type of the variable.

                let indent4 = indent3 + 1;

                for symbol in &import.symbols {

                    self.kv(indent3).with_s_key("AliasedSymbol");

                    self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name);

                    self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias);

                    self.kv(indent4).with_s_key("Definition")

                        .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));

                }

            }

        }

    }

    //--------------------------------------------------------------------------

    // Top-level definition writing

    //--------------------------------------------------------------------------

    fn write_definition(&mut self, heap: &Heap, def_id: DefinitionId, indent: usize) {

        let indent2 = indent + 1;

        let indent3 = indent2 + 1;

        let indent4 = indent3 + 1;

        match &heap[def_id] {

            Definition::Struct(_) => todo!("implement Definition::Struct"),

            Definition::Enum(_) => todo!("implement Definition::Enum"),

            Definition::Component(def) => {

                self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)

                    .with_s_key("DefinitionComponent");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);

                self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);

                self.kv(indent2).with_s_key("Parameters");

                for param_id in &def.parameters {

                }

                self.kv(indent2).with_s_key("Body");

                self.write_stmt(heap, def.body, indent3);

            }

        }

    }

    fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {

        let stmt = &heap[stmt_id];

        let indent2 = indent + 1;

        let indent3 = indent2 + 1;

        match stmt {

            Statement::Block(stmt) => {

                self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)

                    .with_s_key("Block");

                for stmt_id in &stmt.statements {

                    self.write_stmt(heap, *stmt_id, indent2);

                }

            },

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Channel(stmt) => {

                        self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)

                            .with_s_key("LocalChannel");

                        self.kv(indent2).with_s_key("From");

                        self.write_local(heap, stmt.from, indent3);

                        self.kv(indent2).with_s_key("To");

                        self.write_local(heap, stmt.to, indent3);

        Some(v) => write!(target, "Some({})", v),

        None => target.write_str("None")

    };

}

fn write_type(target: &mut String, heap: &Heap, t: &ParserType) {

    use ParserTypeVariant as PTV;

    let mut embedded = Vec::new();

    match &t.variant {

        PTV::Input(id) => { target.write_str("in"); embedded.push(*id); }

        PTV::Output(id) => { target.write_str("out"); embedded.push(*id) }

        PTV::Array(id) => { target.write_str("array"); embedded.push(*id) }

        PTV::Message => { target.write_str("msg"); }

        PTV::Bool => { target.write_str("bool"); }

        PTV::Byte => { target.write_str("byte"); }

        PTV::Short => { target.write_str("short"); }

        PTV::Int => { target.write_str("int"); }

        PTV::Long => { target.write_str("long"); }

        PTV::String => { target.write_str("str"); }

        PTV::IntegerLiteral => { target.write_str("int_lit"); }

        PTV::Inferred => { target.write_str("auto"); }

        PTV::Symbolic(symbolic) => {

            target.write_str(&String::from_utf8_lossy(&symbolic.identifier.value));

            embedded.extend(&symbolic.poly_args);

        }

    };

    if !embedded.is_empty() {

        target.write_str("<");

        for (idx, embedded_id) in embedded.into_iter().enumerate() {

            if idx != 0 { target.write_str(", "); }

            write_type(target, heap, &heap[embedded_id]);

        }

        target.write_str(">");

    }

}

fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {

    use ExpressionParent as EP;

    *target = match parent {

        EP::None => String::from("None"),

        EP::Memory(id) => format!("MemoryStmt({})", id.0.0.index),

        EP::If(id) => format!("IfStmt({})", id.0.index),

        EP::While(id) => format!("WhileStmt({})", id.0.index),

        EP::Return(id) => format!("ReturnStmt({})", id.0.index),

        EP::Assert(id) => format!("AssertStmt({})", id.0.index),

mod depth_visitor;

mod symbol_table;

// mod type_table_old;

mod type_table;

mod visitor;

mod visitor_linker;

mod utils;

use depth_visitor::*;

use symbol_table::SymbolTable;

use visitor::Visitor2;

use visitor_linker::ValidityAndLinkerVisitor;

use type_table::{TypeTable, TypeCtx};

use crate::protocol::ast::*;

use crate::protocol::inputsource::*;

use crate::protocol::lexer::*;

use std::collections::HashMap;

use crate::protocol::ast_printer::ASTWriter;

// TODO: @fixme, pub qualifier

pub(crate) struct LexedModule {

    pub(crate) source: InputSource,

    module_name: Vec<u8>,

    version: Option<u64>,

    root_id: RootId,

}

impl From<ConcreteTypeVariant> for InferredPart {

    fn from(v: ConcreteTypeVariant) -> Self {

        use ConcreteTypeVariant as CTV;

        use InferredPart as IP;

        match v {

            CTV::Message => IP::Message,

            CTV::Bool => IP::Bool,

            CTV::Byte => IP::Byte,

            CTV::Short => IP::Short,

            CTV::Int => IP::Int,

            CTV::Long => IP::Long,

            CTV::String => IP::String,

            CTV::Array => IP::Array,

            CTV::Slice => IP::Slice,

            CTV::Input => IP::Input,

            CTV::Output => IP::Output,

            CTV::Instance(definition_id, num_sub) => IP::Instance(definition_id, num_sub),

        }

    }

}

pub(crate) struct InferenceType {

    origin: ParserTypeId,

    inferred: Vec<InferredPart>,

}

impl InferenceType {

    fn new(inferred_type: ParserTypeId) -> Self {

    }

    fn assign_concrete(&mut self, concrete_type: &ConcreteType) {

        self.inferred.clear();

        self.inferred.reserve(concrete_type.v.len());

        for variant in concrete_type.v {

            self.inferred.push(InferredPart::from(variant))

        }

    }

}

// TODO: @cleanup I will do a very dirty implementation first, because I have no idea

//  what I am doing.

// Very rough idea:

//  - go through entire AST first, find all places where we have inferred types

//      (which may be embedded) and store them in some kind of map.

//  - go through entire AST and visit all expressions depth-first. We will

//      attempt to resolve the return type of each expression. If we can't then

//      we store them in another lookup map and link the dependency on an

//      inferred variable to that expression.

//  - keep iterating until we have completely resolved all variables.

/// This particular visitor will recurse depth-first into the AST and ensures

/// that all expressions have the appropriate types. At the moment this implies:

///

///     - Type checking arguments to unary and binary operators.

///     - Type checking assignment, indexing, slicing and select expressions.

///     - Checking arguments to functions and component instantiations.

///

/// This will be achieved by slowly descending into the AST. At any given

/// expression we may depend on

pub(crate) struct TypeResolvingVisitor {

    // Buffers for iteration over substatements and subexpressions

    stmt_buffer: Vec<StatementId>,

    expr_buffer: Vec<ExpressionId>,

    // If instantiating a monomorph of a polymorphic proctype, then we store the

    // Mapping from parser type to inferred type. We attempt to continue to

    // specify these types until we're stuck or we've fully determined the type.

    infer_types: HashMap<ParserTypeId, InferenceType>,

    // Mapping from variable ID to parser type, optionally inferred, so then

    var_types: HashMap<VariableId, ParserTypeId>,

}

impl TypeResolvingVisitor {

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

        TypeResolvingVisitor{

            stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),

            expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),

            infer_types: HashMap::new(),

            var_types: HashMap::new(),

        }

    }

    fn reset(&mut self) {

        self.stmt_buffer.clear();

        self.expr_buffer.clear();

        self.infer_types.clear();

        self.var_types.clear();

    }

}

impl Visitor2 for TypeResolvingVisitor {

    // Definitions

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {

        self.reset();

        let comp_def = &ctx.heap[id];

        for param_id in comp_def.parameters.clone() {

            let param = &ctx.heap[param_id];

            self.var_types.insert(param_id.upcast(), param.parser_type);

        }

        // Transfer statements for traversal

        let block = &ctx.heap[id];

        for stmt_id in block.statements.clone() {

            self.visit_stmt(ctx, stmt_id);

        }

        Ok(())

    }

    fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {

        let memory_stmt = &ctx.heap[id];

        let local = &ctx.heap[memory_stmt.variable];

        self.var_types.insert(memory_stmt.variable, )

        Ok(())

    }

    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

        Ok(())

    }

}

impl TypeResolvingVisitor {

    fn insert_parser_type_if_needs_inference(

        &mut self, ctx: &mut Ctx, root_id: RootId, parser_type_id: ParserTypeId

    ) -> Result<(), ParseError2> {

        use ParserTypeVariant as PTV;

        let mut to_consider = vec![parser_type_id];

        while !to_consider.is_empty() {

            let parser_type_id = to_consider.pop().unwrap();

                PTV::Inferred => {

                    self.env.insert(parser_type_id, InferenceType::new(parser_type_id));

                },

                PTV::Array(subtype_id) => { to_consider.push(*subtype_id); },

                PTV::Input(subtype_id) => { to_consider.push(*subtype_id); },

                PTV::Output(subtype_id) => { to_consider.push(*subtype_id); },

                PTV::Symbolic(symbolic) => {

                        },

                        }

                    }

                },

                _ => {} // Builtin, doesn't require inference

            }

        }

    }

}

        Ok(())

    }

    //--------------------------------------------------------------------------

    // ParserType visitors

    //--------------------------------------------------------------------------

    fn visit_parser_type(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {

        // We visit a particular type rooted in a non-ParserType node in the

        // AST. Within this function we set up a buffer to visit all nested

        // ParserType nodes.

        // The goal is to link symbolic ParserType instances to the appropriate

        // definition or symbolic type. Alternatively to throw an error if we

        // cannot resolve the ParserType to either of these (polymorphic) types.

        use ParserTypeVariant as PTV;

        debug_assert!(!self.performing_breadth_pass);

        let init_num_types = self.parser_type_buffer.len();

        self.parser_type_buffer.push(id);

        'resolve_loop: while self.parser_type_buffer.len() > init_num_types {

            let parser_type_id = self.parser_type_buffer.pop().unwrap();

            let parser_type = &ctx.heap[parser_type_id];

                PTV::Message | PTV::Bool |

                PTV::Byte | PTV::Short | PTV::Int | PTV::Long |

                PTV::String |

                PTV::IntegerLiteral | PTV::Inferred => {

                    // Builtin types or types that do not require recursion

                    continue 'resolve_loop;

                },

                PTV::Array(subtype_id) |

                PTV::Input(subtype_id) |

                PTV::Output(subtype_id) => {

                    // Requires recursing

                    self.parser_type_buffer.push(*subtype_id);

                    continue 'resolve_loop;

                },

                PTV::Symbolic(symbolic) => {

                    // Retrieve poly_vars from function/component definition to

                    // match against.

                    let (definition_id, poly_vars) = match self.def_type {

                        DefinitionType::None => unreachable!(),

                        DefinitionType::Primitive(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                        DefinitionType::Composite(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                        DefinitionType::Function(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                    };

                    let mut symbolic_variant = None;

                    for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {

                        if symbolic.identifier.value == poly_var.value {

                            // Type refers to a polymorphic variable.

                            // TODO: @hkt Maybe allow higher-kinded types?

                            if !symbolic.poly_args.is_empty() {

                                return Err(ParseError2::new_error(

                                    &ctx.module.source, symbolic.identifier.position, 

                                    "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)"

                                ));

                            }

                            symbolic_variant = Some(SymbolicParserTypeVariant::PolyArg(definition_id, poly_var_idx));

                        }

                    }

                    if let Some(symbolic_variant) = symbolic_variant {

                    } else {

                        // Must be a user-defined type, otherwise an error

                        let found_type = find_type_definition(

                            &ctx.symbols, &ctx.types, ctx.module.root_id, &symbolic.identifier

                        ).as_parse_error(&ctx.module.source)?;

                        symbolic_variant = Some(SymbolicParserTypeVariant::Definition(found_type.ast_definition));

                        // TODO: @function_ptrs: Allow function pointers at some

                        //  point in the future

                        if found_type.definition.type_class().is_proc_type() {

                            return Err(ParseError2::new_error(

                                &ctx.module.source, symbolic.identifier.position,

                                &format!(

                                    "This identifier points to a {} type, expected a datatype",

                                    found_type.definition.type_class()

                                )

                            ));

                        }

                        // If the type is polymorphic then we have two cases: if

                        // the programmer did not specify the polyargs then we 

                        // assume we're going to infer all of them. Otherwise we

                        // make sure that they match in count.

                        if !found_type.poly_args.is_empty() && symbolic.poly_args.is_empty() {

                            // All inferred

                            (

                                SymbolicParserTypeVariant::Definition(found_type.ast_definition),

                                found_type.poly_args.len()

                            )

                        } else if symbolic.poly_args.len() != found_type.poly_args.len() {

                            return Err(ParseError2::new_error(

                                &ctx.module.source, symbolic.identifier.position,

                                &format!(

                                    "Expected {} polymorpic arguments (or none, to infer them), but {} were specified",

                                    found_type.poly_args.len(), symbolic.poly_args.len()

                                )

                            ))

                        } else {

                            // If here then the type is not polymorphic, or all 

                            // types are properly specified by the user.

                            for specified_poly_arg in &symbolic.poly_args {

                                self.parser_type_buffer.push(*specified_poly_arg);

                            }

                        }

                    }

                }

            };

            // If here then type is symbolic, perform a mutable borrow to set

            // the target of the symbolic type.

            for _ in 0..num_inferred_to_allocate {

                self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType{

                    this,

            }

        }

        Ok(())

    }

}

enum FindOfTypeResult {

    // Identifier was exactly matched, type matched as well

    Found(DefinitionId),

    // Identifier was matched, but the type differs from the expected one

    TypeMismatch(&'static str),

    // Identifier could not be found

    NotFound,

}

impl ValidityAndLinkerVisitor {

    //--------------------------------------------------------------------------

    // Special traversal

    //--------------------------------------------------------------------------

    /// Will visit a statement with a hint about its wrapping statement. This is

    /// used to distinguish block statements with a wrapping synchronous

    /// statement from normal block statements.

    fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {

        msg ma = null;

        msg mb = null;

        while(true) synchronous {

            if(fires(a)) {

                // b and c also fire!

                if(fires(leftfirsti)) {

                    // left first! DO USE DUMMY

                    ma = get(a);

                    put(c, ma);

                    mb = get(b);

                    // using dummy!

                    put(leftfirsto, ma);

                    get(leftfirsti);

                } else {

                    // right first! DON'T USE DUMMY

                    mb = get(b);

                    put(c, mb);

                    ma = get(a);

                }

                assert(ma == mb);

            }

        }

    }

    primitive quick_test(in<msg> a, in<msg> b) {

        while(true) synchronous {

            if (fires(a)) {

                ma = get(a);

            }

            if (fires(b)) {

                ma = get(b);

            }

            if (fires(a) && fires(b)) {

                ma = get(a) + get(b);

            }

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));

    /*

    [native]p0-->g0[eq]p1--.

                 g1        |

                 ^---------`

    */

    let [p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    c.add_component(b"eq", &[g0, g1, p1]).unwrap();