ScopedSection{

            inner: &mut self.inner,

            start_size,

            cur_size: start_size

        }

    }

}

#[cfg(debug_assertions)]

impl<T: Sized + Copy> Drop for ScopedBuffer<T> {

    fn drop(&mut self) {

        // Make sure that everyone cleaned up the buffer neatly

use super::arena::{Arena, Id};

use crate::collections::StringRef;

use crate::protocol::inputsource::*;

use crate::protocol::input_source2::{InputPosition2, InputSpan};

/// Helper macro that defines a type alias for a AST element ID. In this case 

/// only used to alias the `Id<T>` types.

macro_rules! define_aliased_ast_id {

    // Variant where we just defined the alias, without any indexing

    ($name:ident, $parent:ty) => {

        pub type $name = $parent;

define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));

define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));

define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));

define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));

define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));

define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));

define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));

define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));

define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));

define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));

define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));

    pub pragmas: Vec<PragmaId>,

    pub imports: Vec<ImportId>,

    pub definitions: Vec<DefinitionId>,

}

impl Root {

    pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {

        for &def in self.definitions.iter() {

                return Some(def);

            }

        }

        None

    }

}

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

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

    New(NewStatementId),

    ExpressionStmt(ExpressionStatementId),

    Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)

}

#[derive(Debug, Clone)]

pub(crate) mod pass_tokenizer;

pub(crate) mod pass_symbols;

pub(crate) mod pass_imports;

pub(crate) mod pass_definitions;

mod type_resolver;

mod visitor;

mod utils;

use depth_visitor::*;

use tokens::*;

use crate::collections::*;

use symbol_table2::SymbolTable;

use visitor::Visitor2;

use type_resolver::{TypeResolvingVisitor, ResolveQueue};

use type_table::{TypeTable, TypeCtx};

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

use crate::protocol::input_source2::{InputSource2 as InputSource};

use crate::protocol::lexer::*;

    }

    pub fn parse(&mut self) -> Result<(), ParseError> {

        self.resolve_symbols_and_types()?;

        // Validate and link all modules

        for module in &self.modules {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                module,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

        let expression_id = self.consume_primary_expression(module, iter, ctx)?;

        let expression = &ctx.heap[expression_id];

        let mut valid = false;

        let mut call_id = CallExpressionId.new_invalid();

        if let Expression::Call(expression) = expression {

                call_id = expression.this;

                valid = true;

            }

        }

        if !valid {

            return Err(ParseError::new_error_str_at_span(

                source, InputSpan::from_positions(start_pos, iter.last_valid_pos()),

            ));

        }

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

        debug_assert!(!call_id.is_invalid());

        Ok(ctx.heap.alloc_new_statement(|this| NewStatement{

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

use crate::protocol::parser::{

    type_table::*,

    utils::*,

};

use super::visitor::{

    STMT_BUFFER_INIT_CAPACITY,

    Visitor2, 

    VisitorResult

};

#[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 } }

}

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

///

///

/// Because of this scheme expressions will not be visited in the breadth-first

/// pass.

    /// `in_sync` is `Some(id)` if the visitor is visiting the children of a

    /// synchronous statement. A single value is sufficient as nested

    /// synchronous statements are not allowed

    in_sync: Option<SynchronousStatementId>,

    /// `in_while` contains the last encountered `While` statement. This is used

    /// to resolve unlabeled `Continue`/`Break` statements.

    in_while: Option<WhileStatementId>,

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

    // scope), the definition variant we are considering, and whether the

    // visitor is performing breadthwise block statement traversal.

    cur_scope: Option<Scope>,

    def_type: DefinitionType,

    // Parent expression (the previous stmt/expression we visited that could be

    // used as an expression parent)

    expr_parent: ExpressionParent,

    // Keeping track of relative position in block in the breadth-first pass.

    // May not correspond to block.statement[index] if any statements are

    // inserted after the breadth-pass

    relative_pos_in_block: u32,

    // Single buffer of statement IDs that we want to traverse in a block.

    // Required to work around Rust borrowing rules and to prevent constant

    // cloning of vectors.

    // Another buffer, now with expression IDs, to prevent constant cloning of

    // vectors while working around rust's borrowing rules

}

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

        Self{

            in_sync: None,

            in_while: None,

            cur_scope: None,

            expr_parent: ExpressionParent::None,

            def_type: DefinitionType::None,

            relative_pos_in_block: 0,

        }

    }

    fn reset_state(&mut self) {

        self.in_sync = None;

        self.in_while = None;

        self.cur_scope = None;

        self.expr_parent = ExpressionParent::None;

        self.def_type = DefinitionType::None;

        self.relative_pos_in_block = 0;

        self.statement_buffer.clear();

        self.expression_buffer.clear();

    }

}

    //--------------------------------------------------------------------------

    // Definition visitors

    //--------------------------------------------------------------------------

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

        self.reset_state();

            ComponentVariant::Primitive => DefinitionType::Primitive(id),

            ComponentVariant::Composite => DefinitionType::Composite(id),

        };

        self.cur_scope = Some(Scope::Definition(id.upcast()));

        self.expr_parent = ExpressionParent::None;

        // Visit statements in component body

        let body_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_id)?;

        self.check_post_definition_state();

        Ok(())

    }

        // Set internal statement indices

        self.def_type = DefinitionType::Function(id);

        self.cur_scope = Some(Scope::Definition(id.upcast()));

        self.expr_parent = ExpressionParent::None;

        // Visit statements in function body

        let body_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_id)?;

        self.check_post_definition_state();

        Ok(())

    }

    //--------------------------------------------------------------------------

    fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {

        self.visit_block_stmt_with_hint(ctx, id, None)

    }

        Ok(())

    }

        Ok(())

    }

    fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {

        let body_id = ctx.heap[id].body;

        self.visit_stmt(ctx, body_id)?;

        Ok(())

    }

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

        // Traverse expression and bodies

        let (test_id, true_id, false_id) = {

            let stmt = &ctx.heap[id];

            (stmt.test, stmt.true_body, stmt.false_body)

        };

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

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

        self.visit_expr(ctx, test_id)?;

        self.expr_parent = ExpressionParent::None;

        }

        Ok(())

    }

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

        let (test_id, body_id) = {

            let stmt = &ctx.heap[id];

            (stmt.test, stmt.body)

        };

        let old_while = self.in_while.replace(id);

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

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

        self.visit_expr(ctx, test_id)?;

        self.expr_parent = ExpressionParent::None;

        self.in_while = old_while;

        Ok(())

    }

    fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {

        let target_end_while = {

            let stmt = &ctx.heap[id];

            let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?;

            let target_while = &ctx.heap[target_while_id];

            debug_assert!(target_while.end_while.is_some());

            target_while.end_while.unwrap()

        };

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

        stmt.target = Some(target_end_while);

        Ok(())

    }

    fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {

        let target_while_id = {

            let stmt = &ctx.heap[id];

            self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?

        };

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

        Ok(())

    }

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

        // Check for validity of synchronous statement

        if self.in_sync.is_some() {

            // Nested synchronous statement

        }

            ));

        }

        let sync_body = ctx.heap[id].body;

        let old = self.in_sync.replace(id);

        self.in_sync = old;

        Ok(())

    }

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

        let stmt = &ctx.heap[id];

        }

        // If here then we are within a function

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

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

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

        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 so if the value does

            // not match, then we must be inside a sync scope

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

            let goto_stmt = &ctx.heap[id];

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

            return Err(

            );

        }

        Ok(())

    }

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

            let new_stmt = &ctx.heap[id];

        }

        let call_expr_id = ctx.heap[id].expression;

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

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

        self.visit_call_expr(ctx, call_expr_id)?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

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

        let expr_id = ctx.heap[id].expression;

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

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

        self.visit_expr(ctx, expr_id)?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

    //--------------------------------------------------------------------------

    // Expression visitors

    //--------------------------------------------------------------------------

    fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        let left_expr_id = assignment_expr.left;

        let right_expr_id = assignment_expr.right;

        let old_expr_parent = self.expr_parent;

        self.visit_expr(ctx, right_expr_id)?;

        self.expr_parent = old_expr_parent;

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

        let test_expr_id = conditional_expr.test;

        let true_expr_id = conditional_expr.true_expression;

        let false_expr_id = conditional_expr.false_expression;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        let left_expr_id = binary_expr.left;

        let right_expr_id = binary_expr.right;

        let old_expr_parent = self.expr_parent;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {

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

        let expr_id = unary_expr.expression;

        let old_expr_parent = self.expr_parent;

        unary_expr.parent = old_expr_parent;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        let subject_expr_id = indexing_expr.subject;

        let index_expr_id = indexing_expr.index;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        let subject_expr_id = slicing_expr.subject;

        let from_expr_id = slicing_expr.from_index;

        let to_expr_id = slicing_expr.to_index;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {

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

        let expr_id = select_expr.subject;

        let old_expr_parent = self.expr_parent;

        select_expr.parent = old_expr_parent;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

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

        let old_num_exprs = self.expression_buffer.len();

        self.expression_buffer.extend(&array_expr.elements);

        let new_num_exprs = self.expression_buffer.len();

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {

        const FIELD_NOT_FOUND_SENTINEL: usize = usize::max_value();

        let old_expr_parent = self.expr_parent;

            Literal::Null | Literal::True | Literal::False |

            Literal::Character(_) | Literal::Integer(_) => {

                // Just the parent has to be set, done above

            },

            Literal::Struct(literal) => {

                let upcast_id = id.upcast();

        self.expr_parent = old_expr_parent;

        Ok(())

    }

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

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

        match &mut call_expr.method {