* statement" field. Because it is so common, this file contain two macros that

 * perform that operation.

 *

 * To make storing types for polymorphic procedures simpler and more efficient,

 * we assign to each expression in the procedure a unique ID. This is what the

 * "next expression index" field achieves. Each expression simply takes the

 * current value, and then increments this counter.

 */

use crate::collections::{ScopedBuffer};

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

use crate::protocol::input_source::*;

use crate::protocol::parser::symbol_table::*;

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

use super::visitor::{

    BUFFER_INIT_CAP_SMALL,

    BUFFER_INIT_CAP_LARGE,

    Ctx,

    Visitor,

    VisitorResult

};

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

struct ControlFlowStatement {

    in_sync: SynchronousStatementId,

    in_while: WhileStatementId,

    in_scope: ScopeId,

    statement: StatementId, // of 'break', 'continue' or 'goto'

}

/// This particular visitor will go through the entire AST in a recursive manner

/// and check if all statements and expressions are legal (e.g. no "return"

/// statements in component definitions), and will link certain AST nodes to

/// their appropriate targets (e.g. goto statements, or function calls).

///

/// This visitor will not perform control-flow analysis (e.g. making sure that

/// each function actually returns) and will also not perform type checking. So

/// the linking of function calls and component instantiations will be checked

/// and linked to the appropriate definitions, but the return types and/or

/// arguments will not be checked for validity.

///

/// The main idea is, because we're visiting nodes in a tree, to do as much as

/// we can while we have the memory in cache.

pub(crate) struct PassValidationLinking {

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

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

    in_sync: SynchronousStatementId,

        self.expr_parent = ExpressionParent::None;

        // Visit true and false branch. Executor chooses next statement based on

        // test expression, not on if-statement itself. Hence the if statement

        // does not have a static subsequent statement.

        assign_then_erase_next_stmt!(self, ctx, id.upcast());

        let old_scope = self.push_scope(ctx, false, true_case.scope);

        self.visit_stmt(ctx, true_case.body)?;

        self.pop_scope(old_scope);

        assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

        if let Some(false_case) = false_case {

            let old_scope = self.push_scope(ctx, false, false_case.scope);

            self.visit_stmt(ctx, false_case.body)?;

            self.pop_scope(old_scope);

            assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

        }

        self.prev_stmt = end_if_id.upcast();

        Ok(())

    }

    fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {

        let end_while_id = stmt.end_while;

        let test_expr_id = stmt.test;

        let body_stmt_id = stmt.body;

        let scope_id = stmt.scope;

        let old_while = self.in_while;

        self.in_while = id;

        // Visit test expression

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

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

        self.in_test_expr = id.upcast();

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

        self.visit_expr(ctx, test_expr_id)?;

        self.in_test_expr = StatementId::new_invalid();

        // Link up to body statement

        assign_then_erase_next_stmt!(self, ctx, id.upcast());

        self.expr_parent = ExpressionParent::None;

        let old_scope = self.push_scope(ctx, false, scope_id);

        self.visit_stmt(ctx, body_stmt_id)?;

        self.pop_scope(old_scope);

        self.in_while = old_while;

        // Link final entry in while's block statement back to the while. The

        // executor will go to the end-while statement if the test expression

        // is false, so put that in as the new previous stmt