Value::Ref(ValueId::Stack(stack_pos)) => {

                    let abs_stack_pos = self.cur_stack_boundary + stack_pos as usize + 1;

                    self.clone_value(self.stack[abs_stack_pos].clone())

                },

                Value::Ref(ValueId::Heap(heap_pos, val_idx)) => {

                    self.clone_value(self.heap_regions[heap_pos as usize].values[val_idx as usize].clone())

                },

                _ => value,

            };

        }

        // Value does live on heap, copy it

        let source_heap_pos = source_heap_pos.unwrap() as usize;

        let target_heap_pos = self.alloc_heap();

        let target_heap_pos_usize = target_heap_pos as usize;

        let num_values = self.heap_regions[source_heap_pos].values.len();

        for value_idx in 0..num_values {

            let cloned = self.clone_value(self.heap_regions[source_heap_pos].values[value_idx].clone());

            self.heap_regions[target_heap_pos_usize].values.push(cloned);

        }

        match value {

            Value::Message(_) => Value::Message(target_heap_pos),

            Value::Array(_) => Value::Array(target_heap_pos),

            Value::Union(tag, _) => Value::Union(tag, target_heap_pos),

            Value::Struct(_) => Value::Struct(target_heap_pos),

            _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),

        }

    }

    pub(crate) fn drop_value(&mut self, value: Option<HeapPos>) {

        if let Some(heap_pos) = value {

            self.drop_heap_pos(heap_pos);

        }

    }

    pub(crate) fn drop_heap_pos(&mut self, heap_pos: HeapPos) {

        let num_values = self.heap_regions[heap_pos as usize].values.len();

        for value_idx in 0..num_values {

            if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {

                self.drop_heap_pos(other_heap_pos);

            }

        }

        self.heap_regions[heap_pos as usize].values.clear();

        self.free_regions.push_back(heap_pos);

    }

        match self {

            Value::UInt8(v)  => *v as u64,

            Value::UInt16(v) => *v as u64,

            Value::UInt32(v) => *v as u64,

            Value::UInt64(v) => *v as u64,

            _ => unreachable!("called as_unsigned_integer on {:?}", self),

        }

    }

    pub(crate) fn as_signed_integer(&self) -> i64 {

        match self {

            Value::SInt8(v)  => *v as i64,

            Value::SInt16(v) => *v as i64,

            Value::SInt32(v) => *v as i64,

            Value::SInt64(v) => *v as i64,

            _ => unreachable!("called as_signed_integer on {:?}", self)

        }

    }

    /// Returns the heap position associated with the value. If the value

    /// doesn't store anything in the heap then we return `None`.

    pub(crate) fn get_heap_pos(&self) -> Option<HeapPos> {

        match self {

            Value::Message(v) => Some(*v),

            Value::Array(v) => Some(*v),

            Value::Union(_, v) => Some(*v),

            Value::Struct(v) => Some(*v),

            _ => None

        }

    }

}

/// When providing arguments to a new component, or when transferring values

/// from one component's store to a newly instantiated component, one has to

/// transfer stack and heap values. This `ValueGroup` represents such a

/// temporary group of values with potential heap allocations.

///

/// Constructing such a ValueGroup manually requires some extra care to make

/// sure all elements of `values` point to valid elements of `regions`.

///

/// Again: this is a temporary thing, hopefully removed once we move to a

/// bytecode interpreter.

pub struct ValueGroup {

    pub(crate) values: Vec<Value>,

    pub(crate) regions: Vec<Vec<Value>>

}

impl ValueGroup {

        enabled_debug_print!(false, "types", $format, $($args),*);

    };

}

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

use crate::collections::DequeSet;

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

use crate::protocol::input_source::ParseError;

use crate::protocol::parser::ModuleCompilationPhase;

use crate::protocol::parser::type_table::*;

use crate::protocol::parser::token_parsing::*;

use super::visitor::{

    STMT_BUFFER_INIT_CAPACITY,

    EXPR_BUFFER_INIT_CAPACITY,

    Ctx,

    Visitor,

    VisitorResult

};

const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];

const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];

const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];

const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];

const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];

const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];

const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];

const SLICE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Slice, InferenceTypePart::Unknown ];

const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];

/// TODO: @performance Turn into PartialOrd+Ord to simplify checks

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

pub(crate) enum InferenceTypePart {

    // When we infer types of AST elements that support polymorphic arguments,

    // then we might have the case that multiple embedded types depend on the

    // polymorphic type (e.g. func bla(T a, T[] b) -> T[][]). If we can infer

    // the type in one place (e.g. argument a), then we may propagate this

    // information to other types (e.g. argument b and the return type). For

    // this reason we place markers in the `InferenceType` instances such that

    // we know which part of the type was originally a polymorphic argument.

    Marker(u32),

    // Completely unknown type, needs to be inferred

    Unknown,

    // Partially known type, may be inferred to to be the appropriate related 

    // type.

    // IndexLike,      // index into array/slice

    NumberLike,     // any kind of integer/float

    IntegerLike,    // any kind of integer

            ITP::Unknown | ITP::NumberLike |

            ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => false,

            _ => true

        }

    }

    fn is_concrete_number(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |

            ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,

            _ => false,

        }

    }

    fn is_concrete_integer(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |

            ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,

            _ => false,

        }

    }

        use InferenceTypePart as ITP;

        match self {

            _ => false,

        }

    }

    fn is_concrete_port(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            ITP::Input | ITP::Output => true,

            _ => false,

        }

    }

    /// Checks if a part is less specific than the argument. Only checks for 

    /// single-part inference (i.e. not the replacement of an `Unknown` variant 

    /// with the argument)

    fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {

        use InferenceTypePart as ITP;

        (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||

        (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||

        (*self == ITP::PortLike && arg.is_concrete_port())

    }

    /// Checks if a part is more specific

    /// Returns the change in "iteration depth" when traversing this particular

    /// part. The iteration depth is used to traverse the tree in a linear 

    /// fashion. It is basically `number_of_subtypes - 1`

    fn depth_change(&self) -> i32 {

        use InferenceTypePart as ITP;

        match &self {

            ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |

            ITP::Void | ITP::Bool |

            ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |

            ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 |

                -1

            },

            ITP::Marker(_) |

            ITP::ArrayLike | ITP::Message | ITP::Array | ITP::Slice |

                // One subtype, so do not modify depth

                0

            },

            ITP::Instance(_, num_args) => {

                (*num_args as i32) - 1

            }

        }

    }

}

#[derive(Debug, Clone)]

struct InferenceType {

    has_marker: bool,

    is_done: bool,

    parts: Vec<InferenceTypePart>,

}

impl InferenceType {

    /// Generates a new InferenceType. The two boolean flags will be checked in

    /// debug mode.

    fn new(has_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {

        if cfg!(debug_assertions) {

            debug_assert!(!parts.is_empty());

            let parts_body_marker = parts.iter().any(|v| v.is_marker());

            debug_assert_eq!(has_marker, parts_body_marker);

            let parts_done = parts.iter().all(|v| v.is_concrete());

            debug_assert_eq!(is_done, parts_done, "{:?}", parts);

        }

        Self{ has_marker, is_done, parts }

    }

    /// Replaces a type subtree with the provided subtree. The caller must make

    /// sure the the replacement is a well formed type subtree.

    fn replace_subtree(&mut self, start_idx: usize, with: &[InferenceTypePart]) {

    /// Returns an iterator over all body markers and the partial type tree that

    /// follows those markers. If it is a problem that `InferenceType` is 

    /// borrowed by the iterator, then use `find_body_marker`.

    fn marker_iter(&self) -> InferenceTypeMarkerIter {

        InferenceTypeMarkerIter::new(&self.parts)

    }

    /// Given that the `parts` are a depth-first serialized tree of types, this

    /// function finds the subtree anchored at a specific node. The returned 

    /// index is exclusive.

    fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {

        let mut depth = 1;

        let mut idx = start_idx;

        while idx < parts.len() {

            depth += parts[idx].depth_change();

            if depth == 0 {

                return idx + 1;

            }

            idx += 1;

        }

        // If here, then the inference type is malformed

    }

    /// Call that attempts to infer the part at `to_infer.parts[to_infer_idx]` 

    /// using the subtree at `template.parts[template_idx]`. Will return 

    /// `Some(depth_change_due_to_traversal)` if type inference has been 

    /// applied. In this case the indices will also be modified to point to the 

    /// next part in both templates. If type inference has not (or: could not) 

    /// be applied then `None` will be returned. Note that this might mean that 

    /// the types are incompatible.

    ///

    /// As this is a helper functions, some assumptions: the parts are not 

    /// exactly equal, and neither of them contains a marker. Also: only the

    /// `to_infer` parts are checked for inference. It might be that this 

    /// function returns `None`, but that that `template` is still compatible

    /// with `to_infer`, e.g. when `template` has an `Unknown` part.

    fn infer_part_for_single_type(

        to_infer: &mut InferenceType, to_infer_idx: &mut usize,

        template_parts: &[InferenceTypePart], template_idx: &mut usize,

    ) -> Option<i32> {

        use InferenceTypePart as ITP;

        let to_infer_part = &to_infer.parts[*to_infer_idx];

        let template_part = &template_parts[*template_idx];

                ITP::Marker(_) => {

                    // Markers are removed when writing to the concrete type.

                    idx += 1;

                    continue;

                },

                ITP::Unknown | ITP::NumberLike |

                ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {

                    // Should not happen if type inferencing works correctly: we

                    // should have returned a programmer-readable error or have

                    // inferred all types.

                    unreachable!("attempted to convert inference type part {:?} into concrete type", part);

                },

                ITP::Void => CTP::Void,

                ITP::Message => CTP::Message,

                ITP::Bool => CTP::Bool,

                ITP::UInt8 => CTP::UInt8,

                ITP::UInt16 => CTP::UInt16,

                ITP::UInt32 => CTP::UInt32,

                ITP::UInt64 => CTP::UInt64,

                ITP::SInt8 => CTP::SInt8,

                ITP::SInt16 => CTP::SInt16,

                ITP::SInt32 => CTP::SInt32,

                ITP::SInt64 => CTP::SInt64,

                ITP::Character => CTP::Character,

                ITP::Array => CTP::Array,

                ITP::Slice => CTP::Slice,

                ITP::Input => CTP::Input,

                ITP::Output => CTP::Output,

                ITP::Instance(id, num) => CTP::Instance(*id, *num),

            };

            concrete_type.parts.push(converted_part);

            idx += 1;

        }

    }

    /// Writes a human-readable version of the type to a string. This is used

    /// to display error messages

    fn write_display_name(

        buffer: &mut String, heap: &Heap, parts: &[InferenceTypePart], mut idx: usize

    ) -> usize {

        use InferenceTypePart as ITP;

        match &parts[idx] {

            ITP::Marker(_marker_idx) => {

                if debug_log_enabled!() {

                    buffer.push_str(&format!("{{Marker:{}}}", *_marker_idx));

                }

            },

            ITP::Unknown => buffer.push_str("?"),

            ITP::NumberLike => buffer.push_str("numberlike"),

            ITP::IntegerLike => buffer.push_str("integerlike"),

            ITP::ArrayLike => {

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push_str("[?]");

            },

            ITP::PortLike => {

                buffer.push_str("portlike<");

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push('>');

            }

            ITP::Void => buffer.push_str("void"),

            ITP::Bool => buffer.push_str(KW_TYPE_BOOL_STR),

            ITP::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),

            ITP::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),

            ITP::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),

            ITP::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),

            ITP::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),

            ITP::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),

            ITP::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),

            ITP::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),

            ITP::Character => buffer.push_str(KW_TYPE_CHAR_STR),

            ITP::Message => {

                buffer.push_str(KW_TYPE_MESSAGE_STR);

                buffer.push('<');

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push('>');

            },

            ITP::Array => {

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push_str("[]");

            },

            ITP::Slice => {

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push_str("[..]");

            },

            ITP::Input => {

                buffer.push_str(KW_TYPE_IN_PORT_STR);

                buffer.push('<');

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push('>');

            },

            ITP::Output => {

                buffer.push_str(KW_TYPE_OUT_PORT_STR);

                buffer.push('<');

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

        for param_id in comp_def.parameters.clone() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected component arguments to be concrete types");

            self.var_types.insert(param_id, VarData::new_local(var_type));

        }

        // Visit the body and all of its expressions

        let body_stmt_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_stmt_id)

    }

    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> 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");

        debug_log!("{}", "-".repeat(50));

        debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);

        if debug_log_enabled!() {

            debug_log!("Polymorphic variables:");

            for (_idx, poly_var) in self.poly_vars.iter().enumerate() {

                let mut infer_type_parts = Vec::new();

                let _infer_type = InferenceType::new(false, true, infer_type_parts);

                debug_log!(" - [{:03}] {:?}", _idx, _infer_type.display_name(&ctx.heap));

            }

        }

        debug_log!("{}", "-".repeat(50));

        // Reserve data for expression types

        debug_assert!(self.expr_types.is_empty());

        self.expr_types.resize(func_def.num_expressions_in_body as usize, Default::default());

        // Visit parameters

        for param_id in func_def.parameters.clone() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected function arguments to be concrete types");

            self.var_types.insert(param_id, VarData::new_local(var_type));

        }

        // Visit all of the expressions within the body

        let body_stmt_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_stmt_id)

    }

    // Statements

        if progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }

        if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }

        Ok(())

    }

    fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> {

        // Note: our expression type might be fixed by our parent, but we still

        // need to make sure it matches the type associated with our operation.

        use BinaryOperator as BO;

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_id = expr.left;

        let arg2_id = expr.right;

        debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_id));

        debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_id));

        debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

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

            BO::Concatenate => {

            },

            BO::LogicalAnd => {

                // Forced boolean on all

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

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

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

                (progress_expr, progress_arg1, progress_arg2)

            },

            BO::LogicalOr => {

                // Forced boolean on all

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

                let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;

                let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;

                (progress_expr, progress_arg1, progress_arg2)

            },

            BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {

                // All equal of integer type

                let progress_base = self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;

                let (progress_expr, progress_arg1, progress_arg2) =

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

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

        if progress_index { self.queue_expr(ctx, index_id); }

        Ok(())

    }

    fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError> {

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let subject_id = expr.subject;

        let from_id = expr.from_index;

        let to_id = expr.to_index;

        debug_log!("Slicing expr: {}", upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Subject type: {}", self.debug_get_display_name(ctx, subject_id));

        debug_log!("   - FromIdx type: {}", self.debug_get_display_name(ctx, from_id));

        debug_log!("   - ToIdx   type: {}", self.debug_get_display_name(ctx, to_id));

        debug_log!("   - Expr    type: {}", self.debug_get_display_name(ctx, upcast_id));

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

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

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

        let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, from_id, 0, to_id, 0)?;

        debug_log!(" * After:");

        debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.debug_get_display_name(ctx, subject_id));

        debug_log!("   - FromIdx type [{}]: {}", progress_idx_base || progress_from, self.debug_get_display_name(ctx, from_id));

        debug_log!("   - ToIdx   type [{}]: {}", progress_idx_base || progress_to, self.debug_get_display_name(ctx, to_id));

        debug_log!("   - Expr    type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

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

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

        if progress_idx_base || progress_to { self.queue_expr(ctx, to_id); }

        Ok(())

    }

    fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError> {

        let upcast_id = id.upcast();

        debug_log!("Select expr: {}", upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Subject type: {}", self.debug_get_display_name(ctx, ctx.heap[id].subject));

        debug_log!("   - Expr    type: {}", self.debug_get_display_name(ctx, upcast_id));

        let subject_id = ctx.heap[id].subject;

        let subject_expr_idx = ctx.heap[subject_id].get_unique_id_in_definition();

        let select_expr = &ctx.heap[id];

        let expr_idx = select_expr.unique_id_in_definition;

        let infer_expr = &self.expr_types[expr_idx as usize];

        let extra_idx = infer_expr.extra_data_idx;

        fn determine_inference_type_instance<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {

            }

        }

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

        debug_log!(" * After:");

        debug_log!("   - Var  type [{}]: {}", progress_var, self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));

        debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

        Ok(())

    }

    fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {

        if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {

            let expr_idx = ctx.heap[*parent_expr_id].get_unique_id_in_definition();

            self.expr_queued.push_back(expr_idx);

        }

    }

    fn queue_expr(&mut self, ctx: &Ctx, expr_id: ExpressionId) {

        let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();

        self.expr_queued.push_back(expr_idx);

    }

    /// Applies a template type constraint: the type associated with the

    /// supplied expression will be molded into the provided `template`. But

    /// will be considered valid if the template could've been molded into the

    /// expression type as well. Hence the template may be fully specified (e.g.

    /// a bool) or contain "inference" variables (e.g. an array of T)

    fn apply_template_constraint(

        &mut self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]

    ) -> Result<bool, ParseError> {

        let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition(); // TODO: @Temp

        let expr_type = &mut self.expr_types[expr_idx as usize].expr_type;

        match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0, false) {

            SingleInferenceResult::Modified => Ok(true),

            SingleInferenceResult::Unmodified => Ok(false),

            SingleInferenceResult::Incompatible => Err(

                self.construct_template_type_error(ctx, expr_id, template)

            )

        }

    }

    fn apply_template_constraint_to_types(

        to_infer: *mut InferenceType, to_infer_start_idx: usize,

        template: &[InferenceTypePart], template_start_idx: usize

    ) -> Result<bool, ()> {

        match InferenceType::infer_subtree_for_single_type(

        for element in elements {

            match &element.variant {

                // Compiler-only types

                PTV::Void => { infer_type.push(ITP::Void); },

                PTV::InputOrOutput => { infer_type.push(ITP::PortLike); has_inferred = true },

                PTV::ArrayLike => { infer_type.push(ITP::ArrayLike); has_inferred = true },

                PTV::IntegerLike => { infer_type.push(ITP::IntegerLike); has_inferred = true },

                // Builtins

                PTV::Message => {

                    // TODO: @types Remove the Message -> Byte hack at some point...

                    infer_type.push(ITP::Message);

                    infer_type.push(ITP::UInt8);

                },

                PTV::Bool => { infer_type.push(ITP::Bool); },

                PTV::UInt8 => { infer_type.push(ITP::UInt8); },

                PTV::UInt16 => { infer_type.push(ITP::UInt16); },

                PTV::UInt32 => { infer_type.push(ITP::UInt32); },

                PTV::UInt64 => { infer_type.push(ITP::UInt64); },

                PTV::SInt8 => { infer_type.push(ITP::SInt8); },

                PTV::SInt16 => { infer_type.push(ITP::SInt16); },

                PTV::SInt32 => { infer_type.push(ITP::SInt32); },

                PTV::SInt64 => { infer_type.push(ITP::SInt64); },

                PTV::Character => { infer_type.push(ITP::Character); },

                // Special markers

                PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },

                PTV::Inferred => {

                    infer_type.push(ITP::Unknown);

                    has_inferred = true;

                },

                // With nested types

                PTV::Array => { infer_type.push(ITP::Array); },

                PTV::Input => { infer_type.push(ITP::Input); },

                PTV::Output => { infer_type.push(ITP::Output); },

                PTV::PolymorphicArgument(belongs_to_definition, poly_arg_idx) => {

                    let poly_arg_idx = *poly_arg_idx;

                    if use_definitions_known_poly_args {

                        // Refers to polymorphic argument on procedure we're currently processing.

                        // This argument is already known.

                        debug_assert_eq!(*belongs_to_definition, self.definition_type.definition_id());

                        debug_assert!((poly_arg_idx as usize) < self.poly_vars.len());

                    } else {

                        // Polymorphic argument has to be inferred

                        has_markers = true;

                        has_inferred = true;

                        infer_type.push(ITP::Marker(poly_arg_idx));

                        infer_type.push(ITP::Unknown)

                    }

                },

                PTV::Definition(definition_id, num_embedded) => {

                    infer_type.push(ITP::Instance(*definition_id, *num_embedded));

                }

            }

        }

        InferenceType::new(has_markers, !has_inferred, infer_type)

    }

    /// Construct an error when an expression's type does not match. This

    /// happens if we infer the expression type from its arguments (e.g. the

    /// expression type of an addition operator is the type of the arguments)

    /// But the expression type was already set due to our parent (e.g. an

    /// "if statement" or a "logical not" always expecting a boolean)

    fn construct_expr_type_error(

        &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId

    ) -> ParseError {

        // TODO: Expand and provide more meaningful information for humans

        let expr = &ctx.heap[expr_id];

        let arg_expr = &ctx.heap[arg_id];

        let expr_idx = expr.get_unique_id_in_definition();

        let arg_expr_idx = arg_expr.get_unique_id_in_definition();

        let expr_type = &self.expr_types[expr_idx as usize].expr_type;

        let arg_type = &self.expr_types[arg_expr_idx as usize].expr_type;

        return ParseError::new_error_at_span(

            &ctx.module.source, expr.operation_span(), format!(

                "incompatible types: this expression expected a '{}'",

                expr_type.display_name(&ctx.heap)