pub span: InputSpan,

    pub expression: ExpressionId,

    // Phase 2: linker

    pub next: StatementId,

}

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

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

    New(NewStatementId),

    ExpressionStmt(ExpressionStatementId),

    Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)

}

impl ExpressionParent {

    pub fn is_new(&self) -> bool {

        match self {

            ExpressionParent::New(_) => true,

            _ => false,

        }

    }

}

#[derive(Debug, Clone)]

pub enum Expression {

    Assignment(AssignmentExpression),

    Binding(BindingExpression),

    Conditional(ConditionalExpression),

    Binary(BinaryExpression),

    Unary(UnaryExpression),

    Indexing(IndexingExpression),

    Slicing(SlicingExpression),

    Select(SelectExpression),

    Literal(LiteralExpression),

    Cast(CastExpression),

    Call(CallExpression),

    Variable(VariableExpression),

}

impl Expression {

    pub fn as_assignment(&self) -> &AssignmentExpression {

        match self {

            Expression::Assignment(result) => result,

            _ => panic!("Unable to cast `Expression` to `AssignmentExpression`"),

        }

    ($format:literal, $($args:expr),*) => {

        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,

    Visitor2,

    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 STRING_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::String ];

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

    ArrayLike,      // array or slice. Note that this must have a subtype

    PortLike,       // input or output port

    // Special types that cannot be instantiated by the user

    Void, // For builtin functions that do not return anything

    // Concrete types without subtypes

    Bool,

    UInt8,

    UInt16,

    UInt32,

    UInt64,

    SInt8,

    SInt16,

    SInt32,

    SInt64,

    Character,

    String,

    // One subtype

    Message,

    Array,

    Slice,

    Input,

    Output,

    // A user-defined type with any number of subtypes

    Instance(DefinitionId, u32)

}

impl InferenceTypePart {

    fn is_marker(&self) -> bool {

        match self {

            InferenceTypePart::Marker(_) => true,

            _ => false,

        }

    }

    /// Checks if the type is concrete, markers are interpreted as concrete

    /// types.

    fn is_concrete(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            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,

        }

    }

    fn is_concrete_msg_array_or_slice(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            ITP::Array | ITP::Slice | ITP::Message => true,

            _ => 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::ArrayLike && arg.is_concrete_msg_array_or_slice()) ||

    }

    /// 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::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |

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

            ITP::Character | ITP::String => {

                -1

            },

            ITP::Marker(_) |

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

            ITP::PortLike | ITP::Input | ITP::Output => {

                // One subtype, so do not modify depth

                0

            },

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

                (*num_args as i32) - 1

            }

        }

    }

}

impl From<ConcreteTypePart> for InferenceTypePart {

    fn from(v: ConcreteTypePart) -> InferenceTypePart {

        use ConcreteTypePart as CTP;

        use InferenceTypePart as ITP;

        match v {

            return DualInferenceResult::Incompatible;

        }

        if modified_a { type_a.recompute_is_done(); }

        if modified_b { type_b.recompute_is_done(); }

        // If here then we completely inferred the subtrees.

        match (modified_a, modified_b) {

            (false, false) => DualInferenceResult::Neither,

            (false, true) => DualInferenceResult::Second,

            (true, false) => DualInferenceResult::First,

            (true, true) => DualInferenceResult::Both

        }

    }

    /// Attempts to infer the first subtree based on the template. Like

    /// `infer_subtrees_for_both_types`, but now only applying inference to

    /// `to_infer` based on the type information in `template`.

    ///

    /// The `forced_template` flag controls whether `to_infer` is considered

    /// valid if it is more specific then the template. When `forced_template`

    /// is false, then as long as the `to_infer` and `template` types are

    /// compatible the inference will succeed. If `forced_template` is true,

    /// then `to_infer` MUST be less specific than `template` (e.g.

    fn infer_subtree_for_single_type(

        to_infer: &mut InferenceType, mut to_infer_idx: usize,

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

        forced_template: bool,

    ) -> SingleInferenceResult {

        let mut modified = false;

        let mut depth = 1;

        while depth > 0 {

            let to_infer_part = &to_infer.parts[to_infer_idx];

            let template_part = &template[template_idx];

            if to_infer_part == template_part {

                let depth_change = to_infer_part.depth_change();

                depth += depth_change;

                debug_assert_eq!(depth_change, template_part.depth_change());

                to_infer_idx += 1;

                template_idx += 1;

                continue;

            }

            if to_infer_part.is_marker() { to_infer_idx += 1; continue; }

            if template_part.is_marker() { template_idx += 1; continue; }

            // Types are not equal and not markers. So check if we can infer 

        true

    }

    /// Performs the conversion of the inference type into a concrete type.

    /// By calling this function you must make sure that no unspecified types

    /// (e.g. Unknown or IntegerLike) exist in the type.

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

        use InferenceTypePart as ITP;

        use ConcreteTypePart as CTP;

        // Make sure inference type is specified but concrete type is not yet specified

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

        debug_assert!(concrete_type.parts.is_empty());

        concrete_type.parts.reserve(self.parts.len());

        let mut idx = 0;

        while idx < self.parts.len() {

            let part = &self.parts[idx];

            let converted_part = match part {

                ITP::Marker(_) => {

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

                    idx += 1;

                    continue;

                },

                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::String => CTP::String,

                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));

                }

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

            },

            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::String => buffer.push_str(KW_TYPE_STRING_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("[..]");

        let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(

            ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0

        )?;

        debug_assert!(if progress_forced { progress_arg2 } else { true });

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));

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

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

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

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

        Ok(())

    }

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

        let upcast_id = id.upcast();

        let binding_expr = &ctx.heap[id];

        let bound_from_id = binding_expr.bound_from;

        let bound_to_id = binding_expr.bound_to;

        let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, bound_from_id, 0, bound_to_id, 0)?;

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

        if progress_from { self.queue_expr(ctx, bound_from_id); }

        if progress_to { self.queue_expr(ctx, bound_to_id); }

        Ok(())

    }

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

        // Note: test expression type is already enforced

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_expr_id = expr.true_expression;

        let arg2_expr_id = expr.false_expression;

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

        debug_log!(" * Before:");

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

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

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

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

            ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0

        )?;

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));

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

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

        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.temp_get_display_name(ctx, arg1_id));

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

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

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

            BO::Concatenate => {

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

                let progress_expr = self.apply_template_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;

                let progress_arg1 = self.apply_template_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;

                let progress_arg2 = self.apply_template_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;

                // If they're all arraylike, then we want the subtype to match

                let (subtype_expr, subtype_arg1, subtype_arg2) =

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

                (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)

            },

            BO::LogicalAnd => {

            },

            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)

            },

            BO::Equality | BO::Inequality => {

                // Equal2 on args, forced boolean output

                let (progress_arg1, progress_arg2) =

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

                (progress_expr, progress_arg1, progress_arg2)

            },

            BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {

                // Equal2 on args with numberlike type, forced boolean output

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

                let (progress_arg1, progress_arg2) =

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

                (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)

            },

            BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {

                // All equal of number type

                let progress_base = self.apply_template_constraint(ctx, upcast_id, &NUMBERLIKE_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)

            },

        };

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_id));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_id));

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

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

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

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

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

        debug_log!(" * Before:");

        debug_log!("   - Arg  type: {}", self.temp_get_display_name(ctx, arg_id));

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

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

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

                // Equal types of numeric class

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

                let (progress_expr, progress_arg) =

                    self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;

                (progress_base || progress_expr, progress_base || progress_arg)

            },

            UO::BitwiseNot => {

                // Equal types of integer class

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

                let (progress_expr, progress_arg) =

                    self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;

                (progress_base || progress_expr, progress_base || progress_arg)

            },

            UO::LogicalNot => {

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

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

                (progress_expr, progress_arg)

            }

        };

        debug_log!(" * After:");

        debug_log!("   - Arg  type [{}]: {}", progress_arg, self.temp_get_display_name(ctx, arg_id));

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

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

        if progress_arg { self.queue_expr(ctx, arg_id); }

        Ok(())

    }

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

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let subject_id = expr.subject;

        let index_id = expr.index;

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

        debug_log!(" * Before:");

        Ok(())

    }

    fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {

        let expr_id = ctx.heap[id].expression;

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

        self.expr_parent = ExpressionParent::ExpressionStmt(id);

        self.visit_expr(ctx, expr_id)?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

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

    // Expression visitors

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

    fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        let assignment_expr = &mut ctx.heap[id];

        let left_expr_id = assignment_expr.left;

        let right_expr_id = assignment_expr.right;

        let old_expr_parent = self.expr_parent;

        assignment_expr.parent = old_expr_parent;

        assignment_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 0);

        self.must_be_assignable = Some(assignment_expr.span);

        self.visit_expr(ctx, left_expr_id)?;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 1);

        self.must_be_assignable = None;

        self.visit_expr(ctx, right_expr_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        // Check for valid context of binding expression

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module.source, span, "cannot assign to the result from a binding expression"

            ));

        }

        if self.in_test_expr.is_invalid() {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module.source, binding_expr.span,

                "binding expressions can only be used inside the testing expression of 'if' and 'while' statements"

            ));

        }

        if !self.in_binding_expr.is_invalid() {

            let binding_expr = &ctx.heap[id];

            let previous_expr = &ctx.heap[self.in_binding_expr];

            return Err(ParseError::new_error_str_at_span(

                &ctx.module.source, binding_expr.span,

                "nested binding expressions are not allowed"

            ).with_info_str_at_span(

                &ctx.module.source, previous_expr.span,

                "the outer binding expression is found here"

            ));

        }

        let old_expr_parent = self.expr_parent;

        binding_expr.parent = old_expr_parent;

        binding_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        self.in_binding_expr = id;

        // Perform preliminary check on children: binding expressions only make

        // sense if the left hand side is just a variable expression, or if it

        // is a literal of some sort. The typechecker will take care of the rest

        let bound_to_id = binding_expr.bound_to;

        let bound_from_id = binding_expr.bound_from;

        match &ctx.heap[bound_to_id] {

            // Variables may not be binding variables, and literals may

            // actually not contain binding variables. But in that case we just

            // perform an equality check.

            Expression::Variable(_) => {}

            Expression::Literal(_) => {},

            _ => {

                let binding_expr = &ctx.heap[id];

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module.source, binding_expr.span,

                    "the left hand side of a binding expression may only be a variable or a literal expression"

                ));

            // Testing with the 'incorrect' target union

            if (let TestUnion::Four(nope) = lit_2 && let TestUnion::Two(zilch) = lit_8) { }

            return 0;

        }

    ").for_function("foo", |f| { f

        .for_variable("valid_2", |v| { v.assert_concrete_type("u16"); })

        .for_variable("valid_4", |v| { v.assert_concrete_type("u32"); })

        .for_variable("valid_8", |v| { v.assert_concrete_type("u64"); })

        .for_variable("inter_a", |v| { v.assert_concrete_type("u16"); })

        .for_variable("inter_b", |v| { v.assert_concrete_type("u16"); })

        .for_variable("inter_c", |v| { v.assert_concrete_type("u16"); });

    });

    Tester::new_single_source_expect_err("apply || before binding", "

        enum Test{ A, B }

        func foo() -> u32 {

            if (let a = Test::A || 5 + 2 == 7) {

                auto mission_impossible = 5;

            }

            return 0;

        }

    ").error(|e| { e

    });

    Tester::new_single_source_expect_err("apply || after binding", "

        enum Test{ A, B }

        func foo() -> u32 {

            if (5 + 2 == 7 || let b = Test::B) {

                auto magic_number = 7;

            }

            return 0;

        }

    ").error(|e| { e

    });

    Tester::new_single_source_expect_err("apply || before and after binding", "

        enum Test{ A, B }

        func foo() -> u32 {

            if (1 + 2 == 3 || (let a = Test::A && let b = Test::B) || (2 + 2 == 4)) {

                auto darth_vader_says = \"Noooooooooo\";

            }

            return 0;

        }

    ").error(|e| { e

    });

}