#[derive(Debug, Clone)]

pub struct SynchronousStatement {

    pub this: SynchronousStatementId,

    // Phase 1: parser

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

    pub body: BlockStatementId,

    pub end_sync: EndSynchronousStatementId,

}

#[derive(Debug, Clone)]

pub struct EndSynchronousStatement {

    pub this: EndSynchronousStatementId,

    pub start_sync: SynchronousStatementId,

    // Phase 2: linker

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct ForkStatement {

    pub this: ForkStatementId,

    // Phase 1: parser

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

    pub left_body: BlockStatementId,

    pub right_body: Option<BlockStatementId>,

    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

    pub target: Option<LabeledStatementId>,

}

#[derive(Debug, Clone)]

pub struct NewStatement {

    pub this: NewStatementId,

    // Phase 1: parser

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

    pub expression: CallExpressionId,

    // Phase 2: linker

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct ExpressionStatement {

    pub this: ExpressionStatementId,

    // Phase 1: parser

    pub span: InputSpan,

    pub expression: ExpressionId,

    // Phase 2: linker

    pub next: StatementId,

}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

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

        let right_body = if has_ident(&module.source, iter, KW_STMT_OR) {

            iter.consume();

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

            Some(right_body)

        } else {

            None

        };

        Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{

            this,

            span: fork_span,

            left_body,

            right_body,

            end_fork: EndForkStatementId::new_invalid(),

        }))

    }

    fn consume_select_statement(

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

    ) -> Result<SelectStatementId, ParseError> {

        let select_span = consume_exact_ident(&module.source, iter, KW_STMT_SELECT)?;

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

        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

        )?;

        let expressions = scoped_section.into_vec();

        if expressions.is_empty() {

            return Err(ParseError::new_error_str_at_span(&module.source, return_span, "expected at least one return value"));

        } else if expressions.len() > 1 {

            return Err(ParseError::new_error_str_at_span(&module.source, return_span, "multiple return values are not (yet) supported"))

        }

        Ok(ctx.heap.alloc_return_statement(|this| ReturnStatement{

            this,

            span: return_span,

            expressions

        }))

    }

    fn consume_goto_statement(

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

    ) -> Result<GotoStatementId, ParseError> {

        let goto_span = consume_exact_ident(&module.source, iter, KW_STMT_GOTO)?;

        let label = consume_ident_interned(&module.source, iter, ctx)?;

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

        Ok(ctx.heap.alloc_goto_statement(|this| GotoStatement{

            this,

    fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {

        let if_stmt = &ctx.heap[id];

        let true_body_id = if_stmt.true_body;

        let false_body_id = if_stmt.false_body;

        let test_expr_id = if_stmt.test;

        self.visit_expr(ctx, test_expr_id)?;

        self.visit_block_stmt(ctx, true_body_id)?;

        if let Some(false_body_id) = false_body_id {

            self.visit_block_stmt(ctx, false_body_id)?;

        }

        Ok(())

    }

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

        let while_stmt = &ctx.heap[id];

        let body_id = while_stmt.body;

        let test_expr_id = while_stmt.test;

        self.visit_expr(ctx, test_expr_id)?;

        self.visit_block_stmt(ctx, body_id)?;

        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 visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let assign_expr = &ctx.heap[id];

        let left_expr_id = assign_expr.left;

        let right_expr_id = assign_expr.right;

        self.visit_expr(ctx, left_expr_id)?;

        self.visit_expr(ctx, right_expr_id)?;

        self.progress_assignment_expr(ctx, id)

    }

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

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

    Ctx,

    Visitor,

    VisitorResult

};

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

#[derive(PartialEq, Eq)]

enum DefinitionType {

    Primitive(ComponentDefinitionId),

    Composite(ComponentDefinitionId),

    Function(FunctionDefinitionId)

}

impl DefinitionType {

    fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }

    fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }

    fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }

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

        self.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());

        self.prev_stmt = StatementId::new_invalid();

        self.expr_parent = ExpressionParent::None;

        self.must_be_assignable = None;

        self.relative_pos_in_block = 0;

        self.next_expr_index = 0

    }

}

macro_rules! assign_then_erase_next_stmt {

    ($self:ident, $ctx:ident, $stmt_id:expr) => {

        if !$self.prev_stmt.is_invalid() {

            $ctx.heap[$self.prev_stmt].link_next($stmt_id);

            $self.prev_stmt = StatementId::new_invalid();

        }

    }

}

macro_rules! assign_and_replace_next_stmt {

    ($self:ident, $ctx:ident, $stmt_id:expr) => {

        if !$self.prev_stmt.is_invalid() {

            $ctx.heap[$self.prev_stmt].link_next($stmt_id);

        }

        $self.prev_stmt = $stmt_id;

        // Visit the respective bodies. Like the if statement, a fork statement

        // does not have a single static subsequent statement. It forks and then

        // each fork has a different next statement.

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

        self.visit_block_stmt(ctx, left_body_id)?;

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

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

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

        }

        self.prev_stmt = end_fork_id.upcast();

        Ok(())

    }

    fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {

        let select_stmt = &ctx.heap[id];

        let end_select_id = select_stmt.end_select;

        // Select statements may only occur inside sync blocks

        if self.in_sync.is_invalid() {

            return Err(ParseError::new_error_str_at_span(

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

                "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(())

    }

    fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {

        let target_id = self.find_label(ctx, &ctx.heap[id].label)?;

        ctx.heap[id].target = Some(target_id);

        let target = &ctx.heap[target_id];

        if self.in_sync != target.in_sync {

            // We can only goto the current scope or outer scopes. Because

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

            // statement.

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

            let goto_stmt = &ctx.heap[id];

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

            return Err(

                ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")

                .with_info_str_at_span(&ctx.module().source, target.label.span, "this is the target of the goto statement")

                .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")

            );

        }

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

        Ok(())

    }

                }

                expr_section.forget();

            },

            Literal::Array(literal) | Literal::Tuple(literal) => {

                // Visit all expressions in the array

                let upcast_id = id.upcast();

                let expr_section = self.expression_buffer.start_section_initialized(literal);

                for expr_idx in 0..expr_section.len() {

                    let expr_id = expr_section[expr_idx];

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

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_section.forget();

            }

        }

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {

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

        };

        let num_provided_args = call_expr.arguments.len();

        if num_provided_args != num_expected_args {

            let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };

            let call_span = call_expr.full_span;

            return Err(ParseError::new_error_at_span(

                &ctx.module().source, call_span, format!(

                    "expected {} {}, but {} were provided",

                    num_expected_args, argument_text, num_provided_args

                )

            ));

        }

        // Recurse into all of the arguments and set the expression's parent

        let upcast_id = id.upcast();

        let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);

        let old_expr_parent = self.expr_parent;

        call_expr.parent = old_expr_parent;

        call_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        for arg_expr_idx in 0..section.len() {

            let arg_expr_id = section[arg_expr_idx];

                // in which the current variable resides.

                if local.this != *other_local_id &&

                    local_relative_pos >= other_local.relative_pos_in_block &&

                    local.identifier == other_local.identifier {

                    // Collision within this scope

                    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 in any of the parent scope, attempt to add to scope

        self.checked_at_single_scope_add_local(ctx, self.cur_scope, relative_pos, id)

    }

    /// Adds a local variable to the specified scope. Will check the specified

    /// scope for variable conflicts and the symbol table for global conflicts.

    /// Will NOT check parent scopes of the specified scope.

    fn checked_at_single_scope_add_local(

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

                ));

            }