pub nested: Vec<Scope>,

}

impl ScopeNode {

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

        ScopeNode{

            parent: Scope::Definition(DefinitionId::new_invalid()),

            nested: Vec::new(),

        }

    }

}

pub enum VariableKind {

    Parameter,      // in parameter list of function/component

    Local,          // declared in function/component body

    Binding,        // may be bound to in a binding expression (determined in validator/linker)

}

#[derive(Debug, Clone)]

pub struct Variable {

    pub this: VariableId,

    // Parsing

    pub kind: VariableKind,

    pub parser_type: ParserType,

                                    span: parser_type.elements[0].full_span, // TODO: @Span fix

                                    parser_type,

                                    method,

                                    arguments,

                                    definition: target_definition_id,

                                    parent: ExpressionParent::None,

                                    unique_id_in_definition: -1,

                                }).upcast()

                            }

                        }

                    },

                    _ => {

                        return Err(ParseError::new_error_str_at_span(

                            &module.source, parser_type.elements[0].full_span,

                            "unexpected type in expression, note that casting expressions are not yet implemented"

                        ))

                    }

                }

            } else {

                // Check for builtin keywords or builtin functions

                if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {

                    iter.consume();

                    // Parse builtin literal

                    ctx.heap.alloc_literal_expression(|this| LiteralExpression {

                        this,

                        span: ident_span,

                        value,

                        parent: ExpressionParent::None,

                        unique_id_in_definition: -1,

                    }).upcast()

                } else if ident_text == KW_LET {

                    // Binding expression

                    let keyword_span = iter.next_span();

                    iter.consume();

                    consume_token(&module.source, iter, TokenKind::Equal)?;

                    ctx.heap.alloc_binding_expression(|this| BindingExpression{

                        this,

                        span: keyword_span,

                        bound_to,

                        bound_from,

                        parent: ExpressionParent::None,

                        unique_id_in_definition: -1,

                    }).upcast()

                } else if ident_text == KW_CAST {

                    // Casting expression

                    iter.consume();

        if num_embedded != 0 {

            if !allow_inference {

                return Err(ParseError::new_error_str_at_span(source, array_span, "type inference is not allowed here"));

            }

            for _ in 0..num_embedded {

                elements.push(ParserTypeElement { full_span: array_span, variant: ParserTypeVariant::Inferred });

            }

        }

        for _ in 0..first_angle_depth {

        }

        return Ok(ParserType{ elements });

    };

    // We have a polymorphic specification. So we start by pushing the item onto

    // our stack, then start adding entries together with the angle-brace depth

    // at which they're found.

    let mut elements = Vec::new();

    elements.push(Entry{ element, depth: 0 });

    // Start out with the first '<' consumed.

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 {

            _ => 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()) ||

    }

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

        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;

                },

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

            self.visit_expr(ctx, arg_expr_id)?;

        }

        self.progress_call_expr(ctx, id)

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let var_expr = &ctx.heap[id];

        debug_assert!(var_expr.declaration.is_some());

        self.progress_variable_expr(ctx, id)

    }

}

impl PassTyping {

    fn temp_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {

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

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

        expr_type.display_name(&ctx.heap)

    }

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

    }

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

            BO::Concatenate => {

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

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

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

                let progress_arg2 = self.apply_forced_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)

            },

                // 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_forced_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)?;

    /// Determines the `InferenceType` for the expression based on the

    /// expression parent. Note that if the parent is another expression, we do

    /// not take special action, instead we let parent expressions fix the type

    /// of subexpressions before they have a chance to call this function.

    fn insert_initial_expr_inference_type(

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

    ) -> Result<(), ParseError> {

        use ExpressionParent as EP;

        use InferenceTypePart as ITP;

        let expr = &ctx.heap[expr_id];

        let inference_type = match expr.parent() {

                // Should have been set by linker

            EP::ExpressionStmt(_) =>

                // Determined during type inference

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

            EP::Expression(parent_id, idx_in_parent) => {

                // If we are the test expression of a conditional expression,

                // then we must resolve to a boolean

                let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {

                    true

                } else {

                    false

                };

            _ => {

                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"

                ));

            },

        }

        // Visit the children themselves

        self.in_binding_expr_lhs = true;

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

        self.in_binding_expr_lhs = false;

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

        self.expr_parent = old_expr_parent;

        self.in_binding_expr = BindingExpressionId::new_invalid();

        Ok(())

    }

    fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        if let Some(span) = self.must_be_assignable {

            self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);

            self.visit_expr(ctx, arg_expr_id)?;

        }

        section.forget();

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        let var_expr = &ctx.heap[id];

        let variable_id = match self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier) {

            Ok(variable_id) => {

                // Regular variable

                variable_id

            },

            Err(()) => {

                // Couldn't find variable, but if we're in a binding expression,

                // then this may be the thing we're binding to.

                if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, var_expr.identifier.span, "unresolved variable"

                    ));

                }

                // This is a binding variable, but it may only appear in very

                // specific locations.

                let is_valid_binding = match self.expr_parent {

                    ExpressionParent::Expression(expr_id, idx) => {

                        match &ctx.heap[expr_id] {

                            Expression::Binding(_binding_expr) => {

                                // Nested binding is disallowed, and because of

        debug_assert!(self.cur_scope.is_block());

        // No need to use iterator over namespaces if here

        let mut scope = &self.cur_scope;

        loop {

            debug_assert!(scope.is_block());

            let block = &ctx.heap[scope.to_block()];

            for local_id in &block.locals {

                let local = &ctx.heap[*local_id];

                    return Ok(*local_id);

                }

            }

            scope = &block.scope_node.parent;

            if !scope.is_block() {

                // Definition scope, need to check arguments to definition

                match scope {

                    Scope::Definition(definition_id) => {

                        let definition = &ctx.heap[*definition_id];

                        for parameter_id in definition.parameters() {

                            let parameter = &ctx.heap[*parameter_id];

use super::*;

#[test]

fn test_correct_binding() {

}

pub(crate) struct FunctionTester<'a> {

    ctx: TestCtx<'a>,

    def: &'a FunctionDefinition,

}

impl<'a> FunctionTester<'a> {

    fn new(ctx: TestCtx<'a>, def: &'a FunctionDefinition) -> Self {

        Self{ ctx, def }

    }

    pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {

            self.ctx.heap, self.def.body.upcast(),

            &|stmt| {

                            return true;

                        }

                    }

                }

                false

            }

        );

        assert!(

            self.ctx.test_name, name, self.assert_postfix()

        );

            self.ctx.heap, self.def.body.upcast(),

            &|expr| {

                    }

                }

                false

            }

        );

        assert!(

            self.ctx.test_name, name, self.assert_postfix()

        );

        // Construct tester and pass to tester function

        let tester = VariableTester::new(

        );

        f(tester);

        self

    }

    /// Finds a specific expression within a function. There are two matchers:

    /// one outer matcher (to find a rough indication of the expression) and an

    /// inner matcher to find the exact expression. 

    ///

    /// The reason being that, for example, a function's body might be littered

    /// with addition symbols, so we first match on "some_var + some_other_var",

    /// and then match exactly on "+".

        }

    }

    fn assert_postfix(&self) -> String {

        format!("Function{{ name: {} }}", self.def.identifier.value.as_str())

    }

}

pub(crate) struct VariableTester<'a> {

    ctx: TestCtx<'a>,

    definition_id: DefinitionId,

    variable: &'a Variable,

}

impl<'a> VariableTester<'a> {

    fn new(

    ) -> Self {

    }

    pub(crate) fn assert_parser_type(self, expected: &str) -> Self {

        let mut serialized = String::new();

        serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);

        assert_eq!(

            expected, &serialized,

            "[{}] Expected parser type '{}', but got '{}' for {}",

            self.ctx.test_name, expected, &serialized, self.assert_postfix()

        );

        self

    }

    pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {

        // Lookup concrete type in type table

        let mono_data = self.ctx.types.get_procedure_expression_data(&self.definition_id, 0);

        // Serialize and check

        let mut serialized = String::new();

        serialize_concrete_type(&mut serialized, self.ctx.heap, self.definition_id, concrete_type);

        assert_eq!(

            expected, &serialized,

            "[{}] Expected concrete type '{}', but got '{}' for {}",

            self.ctx.test_name, expected, &serialized, self.assert_postfix()

        );

        self

    }