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

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

    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,

        }

        }

    }

    /// 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) => {

        }

    }

    /// 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];

        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,

        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 => {

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

                // 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_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); }

    }

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

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

        .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

    });

}