/// `ScopeNode` is a helper that links scopes in two directions. It doesn't

/// actually contain any information associated with the scope, this may be

/// found on the AST elements that `Scope` points to.

#[derive(Debug, Clone)]

pub struct ScopeNode {

    pub parent: Scope,

    pub nested: Vec<Scope>,

}

impl ScopeNode {

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

        ScopeNode{

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

            nested: Vec::new(),

        }

    }

}

    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)

    // Symbol scanning

    // Parsing

    pub scope_node: ScopeNode,

    pub in_sync: SynchronousStatementId, // may be invalid

    pub in_sync: SynchronousStatementId, // may be invalid

    pub span: InputSpan, // of the binding keyword

    pub bound_to: ExpressionId,

    pub bound_from: ExpressionId,

                    .with_disp_val(&stmt.in_sync.0.index);

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

                self.write_expr(heap, expr.bound_to, indent3);

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

                self.write_expr(heap, expr.bound_from, indent3);

    this.visit_expression(h, h[expr].bound_from)?;

    this.visit_expression(h, h[expr].bound_to)

                scope_node: ScopeNode::new_invalid(),

            scope_node: ScopeNode::new_invalid(),

            in_sync: SynchronousStatementId::new_invalid(),

            in_sync: SynchronousStatementId::new_invalid(),

                } else if ident_text == KW_LET {

                    // Binding expression

                    let keyword_span = iter.next_span();

                    iter.consume();

                    let bound_to = self.consume_expression(module, iter, ctx)?;

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

                    let bound_from = self.consume_expression(module, iter, ctx)?;

                    ctx.heap.alloc_binding_expression(|this| BindingExpression{

                        this,

                        span: keyword_span,

                        bound_to,

                        bound_from,

                        parent: ExpressionParent::None,

                        unique_id_in_definition: -1,

                    }).upcast()

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

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let binding_expr = &ctx.heap[id];

        let bound_to_id = binding_expr.bound_to;

        let bound_from_id = binding_expr.bound_from;

        self.visit_expr(ctx, bound_to_id)?;

        self.visit_expr(ctx, bound_from_id)?;

        self.progress_binding_expr(ctx, id)

    }

            Expression::Binding(expr) => {

                let id = expr.this;

                self.progress_binding_expr(ctx, id)

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

    }

    // Traversal state, all valid IDs if inside a certain AST element. Otherwise

    // `id.is_invalid()` returns true.

    in_sync: SynchronousStatementId,

    in_while: WhileStatementId, // to resolve labeled continue/break

    in_test_expr: StatementId, // wrapping if/while stmt id

    in_binding_expr: BindingExpressionId, // to resolve variable expressions

    in_binding_expr_lhs: bool,

            in_sync: SynchronousStatementId::new_invalid(),

            in_while: WhileStatementId::new_invalid(),

            in_test_expr: StatementId::new_invalid(),

            in_binding_expr: BindingExpressionId::new_invalid(),

            in_binding_expr_lhs: false,

        self.in_sync = SynchronousStatementId::new_invalid();

        self.in_while = WhileStatementId::new_invalid();

        self.in_test_expr = StatementId::new_invalid();

        self.in_binding_expr = BindingExpressionId::new_invalid();

        self.in_binding_expr_lhs = false;

        self.expr_parent = ExpressionParent::None;

        self.must_be_assignable = None;

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

        self.visit_definition_and_assign_local_ids(ctx, id.upcast());

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

        self.visit_definition_and_assign_local_ids(ctx, id.upcast());

        let if_stmt = &ctx.heap[id];

        let test_expr_id = if_stmt.test;

        let true_stmt_id = if_stmt.true_body;

        let false_stmt_id = if_stmt.false_body;

        // Visit test expression

        debug_assert!(self.in_test_expr.is_invalid());

        self.in_test_expr = id.upcast();

        self.visit_expr(ctx, test_expr_id)?;

        self.in_test_expr = StatementId::new_invalid();

        self.visit_block_stmt(ctx, true_stmt_id)?;

        if let Some(false_id) = false_stmt_id {

        let old_while = self.in_while;

        self.in_while = id;

        // Visit test expression

        debug_assert!(self.in_test_expr.is_invalid());

        self.in_test_expr = id.upcast();

        self.in_test_expr = StatementId::new_invalid();

        self.expr_parent = ExpressionParent::None;

        if !self.in_sync.is_invalid() {

            let old_sync_span = ctx.heap[self.in_sync].span;

        debug_assert!(self.in_sync.is_invalid());

        self.in_sync = id;

        self.in_sync = SynchronousStatementId::new_invalid();

            // nested sync statements are not allowed we must be inside a sync

            // statement.

            debug_assert!(!self.in_sync.is_invalid());

            let sync_stmt = &ctx.heap[self.in_sync];

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

        let upcast_id = id.upcast();

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

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

                ));

            },

        }

        // Visit the children themselves

        self.in_binding_expr_lhs = true;

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

        self.visit_expr(ctx, bound_to_id);

        self.in_binding_expr_lhs = false;

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

        self.visit_expr(ctx, bound_from_id);

        self.expr_parent = old_expr_parent;

        self.in_binding_expr = BindingExpressionId::new_invalid();

        Ok(())

    }

                if !self.in_sync.is_invalid() {

                if !self.in_sync.is_invalid() {

                if !self.in_sync.is_invalid() {

                if !self.in_sync.is_invalid() {

        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

                                // the check above we know we're directly at the

                                // LHS of the binding expression

                                debug_assert_eq!(_binding_expr.this, self.in_binding_expr);

                                debug_assert_eq!(idx, 0);

                                true

                            }

                            Expression::Literal(lit_expr) => {

                                // Only struct, unions and arrays can have

                                // subexpressions, so we're always fine

                                if cfg!(debug_assertions) {

                                    match lit_expr.value {

                                        Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) => {},

                                        _ => unreachable!(),

                                    }

                                }

                                true

                            },

                            _ => false,

                        }

                    },

                    _ => {

                        false

                    }

                };

                if !is_valid_binding {

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

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, var_expr.identifier.span,

                        "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"

                    ).with_info_at_span(

                        &ctx.module.source, binding_expr.span, format!(

                            "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",

                            var_expr.identifier.value.as_str()

                        )

                    ));

                }

                // By now we know that this is a valid binding expression. Given

                // that a binding expression must be nested under an if/while

                // statement, we now add the variable to the (implicit) block

                // statement following the if/while statement.

                let bound_identifier = var_expr.identifier.clone();

                let bound_variable_id = ctx.heap.alloc_variable(|this| Variable{

                    this,

                    kind: VariableKind::Binding,

                    parser_type: ParserType{ elements: vec![

                        ParserTypeElement{ full_span: bound_identifier.span, variant: ParserTypeVariant::Inferred }

                    ]},

                    identifier: bound_identifier,

                    relative_pos_in_block: 0,

                    unique_id_in_scope: -1,

                });

                let body_stmt_id = match &ctx.heap[self.in_test_expr] {

                    Statement::If(stmt) => stmt.true_body,

                    Statement::While(stmt) => stmt.body,

                    _ => unreachable!(),

                };

                let body_scope = Scope::Regular(body_stmt_id);

                self.checked_at_single_scope_add_local(ctx, body_scope, 0, bound_variable_id)?;

                bound_variable_id

            }

        };

        let new_scope = match hint {

        match old_scope {

            Scope::Definition(_def_id) => {

                // Don't do anything. Block is implicitly a child of a

                // definition scope.

                if cfg!(debug_assertions) {

                    match &ctx.heap[_def_id] {

                        Definition::Function(proc_def) => debug_assert_eq!(proc_def.body, id),

                        Definition::Component(proc_def) => debug_assert_eq!(proc_def.body, id),

                        _ => unreachable!(),

                    }

                }

            },

            Scope::Regular(block_id) | Scope::Synchronous((_, block_id)) => {

                let parent_block = &mut ctx.heap[block_id];

                parent_block.scope_node.nested.push(new_scope);

            }

        }

        self.cur_scope = new_scope;

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

        body.scope_node.parent = old_scope;

        body.relative_pos_in_parent = self.relative_pos_in_block;

                        self.checked_add_local(ctx, relative_pos, variable_id)?;

                        self.checked_add_local(ctx, relative_pos, from_id)?;

                        self.checked_add_local(ctx, relative_pos, to_id)?;

                self.checked_add_label(ctx, relative_pos, self.in_sync, stmt_id)?;

    fn visit_definition_and_assign_local_ids(&mut self, ctx: &mut Ctx, definition_id: DefinitionId) {

        let mut var_counter = 0;

        // Set IDs on parameters

        let (param_section, body_id) = match &ctx.heap[definition_id] {

            Definition::Function(func_def) => (

                self.variable_buffer.start_section_initialized(&func_def.parameters),

                func_def.body

            ),

            Definition::Component(comp_def) => (

                self.variable_buffer.start_section_initialized(&comp_def.parameters),

                comp_def.body

            ),

            _ => unreachable!(),

        } ;

        for idx in 0..param_section.len() {

            let var_id = param_section[idx];

            let var = &mut ctx.heap[var_id];

            var.unique_id_in_scope = var_counter;

            var_counter += 1;

        }

        param_section.forget();

        // Recurse into body

        self.visit_block_and_assign_local_ids(ctx, body_id, var_counter);

    }

    fn visit_block_and_assign_local_ids(&mut self, ctx: &mut Ctx, block_id: BlockStatementId, mut var_counter: i32) {

        let block_stmt = &mut ctx.heap[block_id];

        block_stmt.first_unique_id_in_scope = var_counter;

        let var_section = self.variable_buffer.start_section_initialized(&block_stmt.locals);

        let mut scope_section = self.statement_buffer.start_section();

        for child_scope in &block_stmt.scope_node.nested {

            debug_assert!(child_scope.is_block(), "found a child scope that is not a block statement");

            scope_section.push(child_scope.to_block().upcast());

        }

        let mut var_idx = 0;

        let mut scope_idx = 0;

        while var_idx < var_section.len() || scope_idx < scope_section.len() {

            let relative_var_pos = if var_idx < var_section.len() {

                ctx.heap[var_section[var_idx]].relative_pos_in_block

            } else {

                u32::MAX

            };

            let relative_scope_pos = if scope_idx < scope_section.len() {

                ctx.heap[scope_section[scope_idx]].as_block().relative_pos_in_parent

            } else {

                u32::MAX

            };

            debug_assert!(!(relative_var_pos == u32::MAX && relative_scope_pos == u32::MAX));

            // In certain cases the relative variable position is the same as

            // the scope position (insertion of binding variables). In that case

            // the variable should be treated first

            if relative_var_pos <= relative_scope_pos {

                let var = &mut ctx.heap[var_section[var_idx]];

                var.unique_id_in_scope = var_counter;

                var_counter += 1;

                var_idx += 1;

            } else {

                // Boy oh boy

                let block_id = ctx.heap[scope_section[scope_idx]].as_block().this;

                self.visit_block_and_assign_local_ids(ctx, block_id, var_counter);

                scope_idx += 1;

            }

        }

        var_section.forget();

        scope_section.forget();

        // Done assigning all IDs, assign the last ID to the block statement scope

        let block_stmt = &mut ctx.heap[block_id];

        block_stmt.next_unique_id_in_scope = var_counter;

    }

    fn checked_add_local(&mut self, ctx: &mut Ctx, relative_pos: u32, id: VariableId) -> Result<(), ParseError> {

            // We immediately go to the parent scope. We check the current scope

            // in the call at the end. Likewise for checking the symbol table.

            scope = &block.scope_node.parent;

            if let Scope::Definition(definition_id) = scope {

                // At outer scope, check parameters of function/component

                for parameter_id in ctx.heap[*definition_id].parameters() {

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

                    if local.identifier == parameter.identifier {

                        return Err(

                            ParseError::new_error_str_at_span(

                                &ctx.module.source, local.identifier.span, "Local variable name conflicts with parameter"

                            ).with_info_str_at_span(

                                &ctx.module.source, parameter.identifier.span, "Parameter definition is found here"

                            )

                        );

                    }

                }

                // No collisions

                break;

            }

            // If here then the parent scope is a block scope

            let local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;

        }