}

}

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

pub enum PrimitiveType {

    Input,

    Output,

    Message,

#[allow(dead_code)]

impl Type {

    pub const INPUT: Type = Type { primitive: PrimitiveType::Input, array: false };

    pub const OUTPUT: Type = Type { primitive: PrimitiveType::Output, array: false };

    pub const MESSAGE: Type = Type { primitive: PrimitiveType::Message, array: false };

impl Display for Type {

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

        match &self.primitive {

            PrimitiveType::Input => {

                write!(f, "in")?;

            }

    // Phase 1: parser

    pub position: InputPosition,

    pub variable: LocalId,

    // Phase 2: linker

    pub next: Option<StatementId>,

}

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

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

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

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

                        self.kv(indent2).with_s_key("Next")

                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));

                    }

    *target = match parent {

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

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

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

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

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

pub enum Value {

    Input(InputValue),

    Output(OutputValue),

    Message(MessageValue),

impl ValueImpl for Value {

    fn exact_type(&self) -> Type {

        match self {

            Value::Input(val) => val.exact_type(),

            Value::Output(val) => val.exact_type(),

            Value::Message(val) => val.exact_type(),

    }

    fn is_type_compatible(&self, h: &Heap, t: &ParserType) -> bool {

        match self {

            Value::Input(_) => InputValue::is_type_compatible_hack(h, t),

            Value::Output(_) => OutputValue::is_type_compatible_hack(h, t),

            Value::Message(_) => MessageValue::is_type_compatible_hack(h, t),

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

        let disp: &dyn Display;

        match self {

            Value::Input(val) => disp = val,

            Value::Output(val) => disp = val,

            Value::Message(val) => disp = val,

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                        // Update store

                    }

                    LocalStatement::Channel(stmt) => {

                        let [from, to] = ctx.new_channel();

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

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

        let backup_pos = self.source.pos();

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

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

            self.source.consume();

        self.consume_string(b"{")?;

        self.consume_whitespace(false)?;

        while self.has_local_statement() {

            self.consume_whitespace(false)?;

        }

        while !self.has_string(b"}") {

            .upcast())

        }

    }

        if self.has_keyword(b"channel") {

        } else {

        }

    }

    fn consume_channel_statement(

            next: None,

        }))

    }

        let position = self.source.pos();

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

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        self.consume_whitespace(false)?;

        self.consume_string(b"=")?;

        self.consume_whitespace(false)?;

        let initial = self.consume_expression(h)?;

            this,

            position,

            parser_type,

            relative_pos_in_block: 0

        });

        self.consume_whitespace(false)?;

        self.consume_string(b";")?;

            this,

            position,

            variable,

            next: None,

    }

    fn consume_labeled_statement(

        &mut self,

        self.consume_keyword(b"struct")?;

        self.consume_whitespace(true)?;

        let struct_ident = self.consume_identifier()?;

        let poly_vars = self.consume_polymorphic_vars()?;

        self.consume_whitespace(false)?;

        self.consume_keyword(b"enum")?;

        self.consume_whitespace(true)?;

        let enum_ident = self.consume_identifier()?;

        let poly_vars = self.consume_polymorphic_vars()?;

        self.consume_whitespace(false)?;

        self.consume_keyword(b"composite")?;

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        let poly_vars = self.consume_polymorphic_vars()?;

        self.consume_whitespace(false)?;

        self.consume_keyword(b"primitive")?;

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        let poly_vars = self.consume_polymorphic_vars()?;

        self.consume_whitespace(false)?;

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

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        let poly_vars = self.consume_polymorphic_vars()?;

        self.consume_whitespace(false)?;

        recursive_local_statement(self, h, stmt)

    }

    fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {

    }

    fn visit_channel_statement(

        &mut self,

    }

}

fn recursive_labeled_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

/// TODO: Needs an optimization pass

/// TODO: Needs a cleanup pass

use std::collections::{HashMap, HashSet, VecDeque};

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

    ) -> VisitorResult {

        // Visit the definition

        debug_assert_eq!(ctx.module.root_id, element.root_id);

        self.visit_definition(ctx, element.definition_id)?;

        // Keep resolving types

    // Definitions

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

        self.definition_type = DefinitionType::Component(id);

        let comp_def = &ctx.heap[id];

        debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");

        for param_id in comp_def.parameters.clone() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);

    }

    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {

        self.definition_type = DefinitionType::Function(id);

        let func_def = &ctx.heap[id];

        debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");

        for param_id in func_def.parameters.clone() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);

        let var_type = self.determine_inference_type_from_parser_type(ctx, local.parser_type, true);

        self.var_types.insert(memory_stmt.variable.upcast(), VarData{ var_type, used_at: Vec::new() });

        Ok(())

    }

impl TypeResolvingVisitor {

    fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError2> {

        // Keep inferring until we can no longer make any progress

        while let Some(next_expr_id) = self.expr_queued.iter().next() {

            let next_expr_id = *next_expr_id;

            self.expr_queued.remove(&next_expr_id);

        // Should have inferred everything

        for (expr_id, expr_type) in self.expr_types.iter() {

            if !expr_type.is_done {

                // TODO: Auto-inference of integerlike types

                let expr = &ctx.heap[*expr_id];

                return Err(ParseError2::new_error(

        let arg1_expr_id = expr.left;

        let arg2_expr_id = expr.right;

        let progress_base = match expr.operation {

            AO::Set =>

                false,

            ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0

        )?;

        if progress_base || progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_arg1 { self.queue_expr(arg1_expr_id); }

        if progress_arg2 { self.queue_expr(arg2_expr_id); }

        let arg1_expr_id = expr.true_expression;

        let arg2_expr_id = expr.false_expression;

        let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(

            ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0

        )?;

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_arg1 { self.queue_expr(arg1_expr_id); }

        if progress_arg2 { self.queue_expr(arg2_expr_id); }

        let arg1_id = expr.left;

        let arg2_id = expr.right;

        let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {

            BO::Concatenate => {

                // Arguments may be arrays/slices, output is always an array

                (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)

            },

                // Equal2 on args, forced boolean output

                let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;

                let progress_arg_base = self.apply_forced_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;

                let (progress_arg1, progress_arg2) =

                    self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;

            },

        };

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_arg1 { self.queue_expr(arg1_id); }

        if progress_arg2 { self.queue_expr(arg2_id); }

        let expr = &ctx.heap[id];

        let arg_id = expr.expression;

        let (progress_expr, progress_arg) = match expr.operation {

            UO::Positive | UO::Negative => {

                // Equal types of numeric class

            }

        };

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_arg { self.queue_expr(arg_id); }

        let subject_id = expr.subject;

        let index_id = expr.index;

        // Make sure subject is arraylike and index is integerlike

        let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;

        let progress_index = self.apply_forced_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;

        let (progress_expr, progress_subject) =

            self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_subject_base || progress_subject { self.queue_expr(subject_id); }

        if progress_index { self.queue_expr(index_id); }

        let from_id = expr.from_index;

        let to_id = expr.to_index;

        // Make sure subject is arraylike and indices are of equal integerlike

        let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;

        let progress_idx_base = self.apply_forced_constraint(ctx, from_id, &INTEGERLIKE_TEMPLATE)?;

        let (progress_expr, progress_subject) =

            self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_subject_base || progress_subject { self.queue_expr(subject_id); }

        if progress_idx_base || progress_from { self.queue_expr(from_id); }

        let expr = &ctx.heap[id];

        let subject_id = expr.subject;

        let (progress_subject, progress_expr) = match &expr.field {

            Field::Length => {

                let progress_subject = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;

            }

        };

        if progress_subject { self.queue_expr(subject_id); }

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        let expr = &ctx.heap[id];

        let expr_elements = expr.elements.clone(); // TODO: @performance

        // All elements should have an equal type

        let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;

        let mut any_progress = false;

            if arg_progress { self.queue_expr(upcast_id); }

        }

        if expr_progress { self.queue_expr_parent(ctx, upcast_id); }

        Ok(())

    //  polymorphic struct/enum/union literals. These likely follow the same

    //  pattern as here.

    fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError2> {

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let extra = self.extra_data.get_mut(&upcast_id).unwrap();

        // Check if we can make progress using the arguments and/or return types

        // while keeping track of the polyvars we've extended

        let mut poly_progress = HashSet::new();

                ctx, upcast_id, signature_type, 0, argument_type, 0

            )?;

            if progress_sig {

                // Progressed signature, so also apply inference to the 

                        Ok(false) => {},

                        Err(()) => { poly_infer_error = true; }

                    }

                }

            }

            if progress_arg {

            ctx, upcast_id, signature_type, 0, expr_type, 0

        )?;

        if progress_sig {

            // As above: apply inference to polyargs as well

                    Ok(false) => {},

                    Err(()) => { poly_infer_error = true; }

                }

            }

        }

        if progress_expr {

        // If we did not have an error in the polymorph inference above, then

        // reapplying the polymorph type to each argument type and the return

        // type should always succeed.

        // TODO: @performance If the algorithm is changed to be more "on demand

        //  argument re-evaluation", instead of "all-argument re-evaluation",

        //  then this is no longer true

                    seek_idx = end_idx;

                }

                // Part of signature was modified, so update expression used as

                // argument as well

                    ctx, arg_expr_id, arg_type, 0, sig_type, 0

                ).expect("no inference error at argument type");

                if progress_arg { self.expr_queued.insert(arg_expr_id); }

            }

            // Again: do the same for the return type

                        self.expr_queued.insert(parent_id);

                    }

                }

            }

        }

        Ok(())

    }

        let var_expr = &ctx.heap[id];

        let var_id = var_expr.declaration.unwrap();

        // Retrieve shared variable type and expression type and apply inference

        let var_data = self.var_types.get_mut(&var_id).unwrap();

        let expr_type = self.expr_types.get_mut(&upcast_id).unwrap();

        }

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        Ok(())

    }

            EP::None =>

                // Should have been set by linker

                unreachable!(),

                // Determined during type inference

                InferenceType::new(false, false, vec![ITP::Unknown]),

            EP::If(_) | EP::While(_) | EP::Assert(_) =>

        // map them back and forth to the polymorphic arguments of the function

        // we are calling.

        let call = &ctx.heap[call_id];

        // Handle the polymorphic variables themselves

        let mut poly_vars = Vec::with_capacity(call.poly_args.len());

            self.visit_parser_type(ctx, parser_type_id)?;

            debug_assert_eq!(self.expr_parent, ExpressionParent::None);

        }

        Ok(())

            }

        }

    }

        T something = a;

        return something;

    }