pub to_type: ParserType,

    pub subject: ExpressionId,

    // Validator/linker

    pub parent: ExpressionParent,

    pub unique_id_in_definition: i32,

}

#[derive(Debug, Clone)]

pub struct CallExpression {

    pub this: CallExpressionId,

    // Parsing

    pub func_span: InputSpan, // of the function name

    pub full_span: InputSpan, // includes the arguments and parentheses

    pub parser_type: ParserType, // of the function call, not the return type

    pub method: Method,

    pub arguments: Vec<ExpressionId>,

    pub definition: DefinitionId,

    // Validator/Linker

    pub parent: ExpressionParent,

    pub unique_id_in_definition: i32,

}

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

pub enum Method {

    Get,

    Put,

    Fires,

    Create,

    Length,

    Assert,

    Print,

    UserFunction,

    UserComponent,

}

#[derive(Debug, Clone)]

pub struct MethodSymbolic {

    pub(crate) parser_type: ParserType,

    pub(crate) definition: DefinitionId

}

#[derive(Debug, Clone)]

pub struct LiteralExpression {

    pub this: LiteralExpressionId,

    // Parsing

    pub span: InputSpan,

    pub value: Literal,

    // Validator/Linker

    pub parent: ExpressionParent,

    pub unique_id_in_definition: i32,

}

#[derive(Debug, Clone)]

pub enum Literal {

    Null, // message

                                Method::Assert => {

                                    let value = cur_frame.expr_values.pop_front().unwrap();

                                    let value = self.store.maybe_read_ref(&value).clone();

                                    if !value.as_bool() {

                                        return Ok(EvalContinuation::BranchInconsistent)

                                    }

                                },

                                Method::Print => {

                                    // Convert the runtime-variant of a string

                                    // into an actual string.

                                    let value = cur_frame.expr_values.pop_front().unwrap();

                                    let value_heap_pos = value.as_string();

                                    let elements = &self.store.heap_regions[value_heap_pos as usize].values;

                                    let mut message = String::with_capacity(elements.len());

                                    for element in elements {

                                        message.push(element.as_char());

                                    }

                                    // Drop the heap-allocated value from the

                                    // store

                                    self.store.drop_heap_pos(value_heap_pos);

                                    println!("{}", message);

                                },

                                Method::UserComponent => {

                                    // This is actually handled by the evaluation

                                    // of the statement.

                                    debug_assert_eq!(heap[expr.definition].parameters().len(), cur_frame.expr_values.len());

                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)

                                },

                                Method::UserFunction => {

                                    // Push a new frame. Note that all expressions have

                                    // been pushed to the front, so they're in the order

                                    // of the definition.

                                    let num_args = expr.arguments.len();

                                    // Determine stack boundaries

                                    let cur_stack_boundary = self.store.cur_stack_boundary;

                                    let new_stack_boundary = self.store.stack.len();

                                    // Push new boundary and function arguments for new frame

                                    self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));

                                    for _ in 0..num_args {

                                        let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());

                                        self.store.stack.push(argument);

                                    }

                                    // Determine the monomorph index of the function we're calling

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

            },

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                        if cfg!(debug_assertions) {

                            let variable = &heap[stmt.variable];

                            debug_assert!(match self.store.read_ref(ValueId::Stack(variable.unique_id_in_scope as u32)) {

                                Value::Unassigned => false,

                                _ => true,

                            });

                        }

                        cur_frame.position = stmt.next;

                        Ok(EvalContinuation::Stepping)

                    },

                    LocalStatement::Channel(stmt) => {

                        // Need to create a new channel by requesting it from

                        // the runtime.

                        match ctx.created_channel() {

                            None => {

                                // No channel is pending. So request one

                            },

                            Some((put_port, get_port)) => {

                                self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), put_port);

                                self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), get_port);

                                cur_frame.position = stmt.next;

                                Ok(EvalContinuation::Stepping)

                            }

                        }

                    }

                }

            },

            Statement::Labeled(stmt) => {

                cur_frame.position = stmt.body;

                Ok(EvalContinuation::Stepping)

            },

            Statement::If(stmt) => {

                debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for if statement");

                let test_value = cur_frame.expr_values.pop_back().unwrap();

                let test_value = self.store.maybe_read_ref(&test_value).as_bool();

                if test_value {

                    cur_frame.position = stmt.true_body.upcast();

                } else if let Some(false_body) = stmt.false_body {

                    cur_frame.position = false_body.upcast();

pub(crate) mod symbol_table;

pub(crate) mod type_table;

pub(crate) mod tokens;

pub(crate) mod token_parsing;

pub(crate) mod pass_tokenizer;

pub(crate) mod pass_symbols;

pub(crate) mod pass_imports;

pub(crate) mod pass_definitions;

pub(crate) mod pass_definitions_types;

pub(crate) mod pass_validation_linking;

pub(crate) mod pass_typing;

mod visitor;

use tokens::*;

use crate::collections::*;

use visitor::Visitor;

use pass_tokenizer::PassTokenizer;

use pass_symbols::PassSymbols;

use pass_imports::PassImport;

use pass_definitions::PassDefinitions;

use pass_validation_linking::PassValidationLinking;

use pass_typing::{PassTyping, ResolveQueue};

use symbol_table::*;

use type_table::TypeTable;

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

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

use crate::protocol::ast_printer::ASTWriter;

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]

pub enum ModuleCompilationPhase {

    Tokenized,              // source is tokenized

    SymbolsScanned,         // all definitions are linked to their type class

    ImportsResolved,        // all imports are added to the symbol table

    DefinitionsParsed,      // produced the AST for the entire module

    TypesAddedToTable,      // added all definitions to the type table

    ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes

    // When we continue with the compiler:

    // Typed,                  // Type inference and checking has been performed

}

pub struct Module {

    // Buffers

    pub source: InputSource,

    pub tokens: TokenBuffer,

    // Identifiers

    pub root_id: RootId,

    pub name: Option<(PragmaId, StringRef<'static>)>,

    pub version: Option<(PragmaId, i64)>,

    pub phase: ModuleCompilationPhase,

}

// TODO: This is kind of wrong. Because when we're producing bytecode we would

//       like the bytecode itself to not have the notion of the size of a pointer

//       type. But until I figure out what we do want I'll just set everything

//       to a 64-bit architecture.

pub struct TargetArch {

    pub array_size_alignment: (usize, usize),

    pub slice_size_alignment: (usize, usize),

    pub string_size_alignment: (usize, usize),

    pub port_size_alignment: (usize, usize),

        // Visit statements in function body

        self.visit_block_stmt(ctx, body_id)?;

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

        // to each of the locals in the procedure.

        ctx.heap[id].num_expressions_in_body = self.next_expr_index;

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

        self.resolve_pending_control_flow_targets(ctx)?;

        Ok(())

    }

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

    // Statement visitors

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

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

        let old_scope = self.push_statement_scope(ctx, Scope::Regular(id));

        // Set end of block

        let block_stmt = &ctx.heap[id];

        let end_block_id = block_stmt.end_block;

        // Traverse statements in block

        let statement_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);

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

        for stmt_idx in 0..statement_section.len() {

            self.relative_pos_in_block = stmt_idx as i32;

            self.visit_stmt(ctx, statement_section[stmt_idx])?;

        }

        statement_section.forget();

        assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());

        self.pop_statement_scope(old_scope);

        Ok(())

    }

    fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {

        let stmt = &ctx.heap[id];

        let expr_id = stmt.initial_expr;

        let variable_id = stmt.variable;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_block, variable_id)?;

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

            },

            Method::Put => {

                expecting_primitive_def = true;

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

            },

            Method::Fires => {

                expecting_primitive_def = true;

                expecting_wrapping_sync_stmt = true;

            },

            Method::Create => {},

            Method::Length => {},

            Method::Assert => {

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

                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 => {

                expecting_wrapping_new_stmt = true;

            },

        }

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

        fn get_span_and_name<'a>(ctx: &'a Ctx, id: CallExpressionId) -> (InputSpan, String) {

            let call = &ctx.heap[id];

            let span = call.func_span;

            let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();

            return (span, name);

        }

        if expecting_primitive_def {

            if !self.def_type.is_primitive() {

                let (call_span, func_name) = get_span_and_name(ctx, id);

                return Err(ParseError::new_error_at_span(

                    &ctx.module().source, call_span,

                    format!("a call to '{}' may only occur in primitive component definitions", func_name)

                ));

            }

        }