pub end_fork: EndForkStatementId,

}

#[derive(Debug, Clone)]

pub struct EndForkStatement {

    pub this: EndForkStatementId,

    pub start_fork: ForkStatementId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct SelectStatement {

    pub this: SelectStatementId,

    pub span: InputSpan, // of the "select" keyword

    pub cases: Vec<SelectCase>,

    pub end_select: EndSelectStatementId,

}

#[derive(Debug, Clone)]

pub struct SelectCase {

    // The guard statement of a `select` is either a MemoryStatement or an

    // ExpressionStatement. Nothing else is allowed by the initial parsing

    pub guard: StatementId,

    pub block: BlockStatementId,

}

#[derive(Debug, Clone)]

pub struct EndSelectStatement {

    pub this: EndSelectStatementId,

    pub start_select: SelectStatementId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct ReturnStatement {

    pub this: ReturnStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the "return" keyword

    pub expressions: Vec<ExpressionId>,

}

#[derive(Debug, Clone)]

pub struct GotoStatement {

    pub this: GotoStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the "goto" keyword

    pub label: Identifier,

    // Phase 2: linker

        let mut cases = Vec::new();

        let mut next = iter.next();

        while Some(TokenKind::CloseCurly) != next {

            let guard = match self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {

                Some(guard_mem_stmt) => guard_mem_stmt.upcast().upcast(),

                None => {

                    let start_pos = iter.last_valid_pos();

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

                    let end_pos = iter.last_valid_pos();

                    let guard_expr_stmt = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{

                        this,

                        span: InputSpan::from_positions(start_pos, end_pos),

                        expression: expr,

                        next: StatementId::new_invalid(),

                    });

                    guard_expr_stmt.upcast()

                },

            };

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

            let block = self.consume_block_or_wrapped_statement(module, iter, ctx)?;

            next = iter.next();

        }

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

        Ok(ctx.heap.alloc_select_statement(|this| SelectStatement{

            this,

            span: select_span,

            cases,

            end_select: EndSelectStatementId::new_invalid(),

        }))

    }

    fn consume_return_statement(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

    ) -> Result<ReturnStatementId, ParseError> {

        let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;

        let mut scoped_section = self.expressions.start_section();

        consume_comma_separated_until(

            TokenKind::SemiColon, &module.source, iter, ctx,

            |_source, iter, ctx| self.consume_expression(module, iter, ctx),

            &mut scoped_section, "an expression", None

        Ok(())

    }

    fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {

        let sync_stmt = &ctx.heap[id];

        let body_id = sync_stmt.body;

        self.visit_block_stmt(ctx, body_id)

    }

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

        let left_body_id = fork_stmt.left_body;

        let right_body_id = fork_stmt.right_body;

        self.visit_block_stmt(ctx, left_body_id)?;

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

        }

        Ok(())

    }

    fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {

        let return_stmt = &ctx.heap[id];

        debug_assert_eq!(return_stmt.expressions.len(), 1);

        let expr_id = return_stmt.expressions[0];

        self.visit_expr(ctx, expr_id)

    }

    fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {

        let new_stmt = &ctx.heap[id];

        let call_expr_id = new_stmt.expression;

        self.visit_call_expr(ctx, call_expr_id)

    }

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

        let expr_stmt = &ctx.heap[id];

        let subexpr_id = expr_stmt.expression;

        self.visit_expr(ctx, subexpr_id)

    }

    // Expressions

    fn definition_id(&self) -> DefinitionId {

        match self {

            DefinitionType::Primitive(v) => v.upcast(),

            DefinitionType::Composite(v) => v.upcast(),

            DefinitionType::Function(v) => v.upcast(),

        }

    }

}

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

pub(crate) struct PassValidationLinking {

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

    // Traversal state, current scope (which can be used to find the parent

    // scope) and the definition variant we are considering.

    cur_scope: Scope,

    def_type: DefinitionType,

    // "Trailing" traversal state, set be child/prev stmt/expr used by next one

    prev_stmt: StatementId,

    expr_parent: ExpressionParent,

    // Set by parent to indicate that child expression must be assignable. The

    // child will throw an error if it is not assignable. The stored span is

    // used for the error's position

    must_be_assignable: Option<InputSpan>,

    // Keeping track of relative positions and unique IDs.

    relative_pos_in_block: i32, // of statements: to determine when variables are visible

    next_expr_index: i32, // to arrive at a unique ID for all expressions within a definition

    // Various temporary buffers for traversal. Essentially working around

    // Rust's borrowing rules since it cannot understand we're modifying AST

    // members but not the AST container.

    variable_buffer: ScopedBuffer<VariableId>,

    definition_buffer: ScopedBuffer<DefinitionId>,

    statement_buffer: ScopedBuffer<StatementId>,

    expression_buffer: ScopedBuffer<ExpressionId>,

}

impl PassValidationLinking {

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

        Self{

            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,

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

            prev_stmt: StatementId::new_invalid(),

            expr_parent: ExpressionParent::None,

            def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),

            must_be_assignable: None,

            relative_pos_in_block: 0,

            next_expr_index: 0,

            variable_buffer: ScopedBuffer::with_capacity(128),

            definition_buffer: ScopedBuffer::with_capacity(128),

            statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),

            expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),

        }

    }

    fn reset_state(&mut self) {

        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.cur_scope = Scope::Definition(DefinitionId::new_invalid());

                "select statements may only occur inside sync blocks"

            ));

        }

        if !self.def_type.is_primitive() {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, select_stmt.span,

                "select statements may only be used in primitive components"

            ));

        }

        // Visit the various arms in the select block

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

        let num_cases = select_stmt.cases.len();

        for case in &select_stmt.cases {

            // Note: we add both to the buffer, retrieve them later in indexed

            // fashion

            case_stmt_ids.push(case.guard);

            case_stmt_ids.push(case.block.upcast());

        }

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

        // Link up the "Select" with the "EndSelect". If there are no cases then

        for idx in 0..num_cases {

            let base_idx = 2 * idx;

            let guard_id     = case_stmt_ids[base_idx    ];

            let arm_block_id = case_stmt_ids[base_idx + 1];

            self.visit_stmt(ctx, guard_id)?;

            self.visit_stmt(ctx, arm_block_id)?;

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

        }

        self.prev_stmt = end_select_id.upcast();

        Ok(())

    }

    fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {

        // Check if "return" occurs within a function

        let stmt = &ctx.heap[id];

        if !self.def_type.is_function() {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, stmt.span,

                "return statements may only appear in function bodies"

            ));

        }

        // If here then we are within a function

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

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

        debug_assert_eq!(ctx.heap[id].expressions.len(), 1);

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

        self.visit_expr(ctx, ctx.heap[id].expressions[0])?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

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

        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 cast expression"

            ))

        }

        let upcast_id = id.upcast();

        let old_expr_parent = self.expr_parent;

        cast_expr.parent = old_expr_parent;

        cast_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        // Recurse into the thing that we're casting

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

        let subject_id = cast_expr.subject;

        self.visit_expr(ctx, subject_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {

        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 call expression"

            ))

        }

        // Check whether the method is allowed to be called within the code's

        // context (in sync, definition type, etc.)

            Method::Get => {

                    }

                }

            },

            Method::Put => {

                    let call_span = call_expr.func_span;

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, call_span,

                    ));

                }

            },

            Method::Fires => {

            },

            Method::Create => {},

            Method::Length => {},

            Method::Assert => {

                if self.def_type.is_function() {

                    let call_span = call_expr.func_span;

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, call_span,

                        "assert statement may only occur in components"

                    ));

                }

            },

            Method::Print => {},

            Method::UserFunction => {},

            Method::UserComponent => {

            },

        }

            if !self.expr_parent.is_new() {

                let call_span = call_expr.func_span;

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, call_span,

                    "cannot call a component, it can only be instantiated by using 'new'"

                ));

            }

        } else {

            if self.expr_parent.is_new() {

                let call_span = call_expr.func_span;

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, call_span,

                    "only components can be instantiated, this is a function"

                ));

            }

        }

        // Check the number of arguments

        let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();

        let num_expected_args = match &call_definition.definition {

            DefinedTypeVariant::Function(definition) => definition.arguments.len(),

            DefinedTypeVariant::Component(definition) => definition.arguments.len(),

            v => unreachable!("encountered {} type in call expression", v.type_class()),

        };

        &mut self, ctx: &mut Ctx, scope: Scope, relative_pos: i32, id: VariableId

    ) -> Result<(), ParseError> {

        // Check the symbol table for conflicts

        {

            let cur_scope = SymbolScope::Definition(self.def_type.definition_id());

            let ident = &ctx.heap[id].identifier;

            if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, ident.span,

                    "local variable declaration conflicts with symbol"

                ).with_info_str_at_span(

                    &ctx.module().source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"

                ));

            }

        }

        // Check the specified scope for conflicts

        let local = &ctx.heap[id];

        debug_assert!(scope.is_block());

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

        for other_local_id in &block.locals {

            let other_local = &ctx.heap[*other_local_id];

            if local.this != other_local.this &&

                local.identifier == other_local.identifier {

                // Collision

                return Err(

                    ParseError::new_error_str_at_span(

                        &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"

                    ).with_info_str_at_span(

                        &ctx.module().source, other_local.identifier.span, "Previous variable is found here"

                    )

                );

            }

        }

        // No collisions

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

        block.locals.push(id);

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

        local.relative_pos_in_block = relative_pos;

        Ok(())

    }

    /// Finds a variable in the visitor's scope that must appear before the

    /// specified relative position within that block.