mod arena;

pub(crate) mod eval;

pub(crate) mod input_source;

mod parser;

#[cfg(test)] mod tests;

pub(crate) mod ast;

use std::sync::Mutex;

use crate::collections::{StringPool, StringRef};

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

use crate::protocol::eval::*;

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

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

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

pub use parser::type_table::TypeId;

/// A protocol description module

pub struct Module {

    pub(crate) source: InputSource,

    pub(crate) root_id: RootId,

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

}

/// Description of a protocol object, used to configure new connectors.

#[repr(C)]

pub struct ProtocolDescription {

    pub(crate) modules: Vec<Module>,

    pub(crate) heap: Heap,

    pub(crate) types: TypeTable,

    pub(crate) pool: Mutex<StringPool>,

}

#[derive(Debug, Clone)]

pub(crate) struct ComponentState {

    pub(crate) prompt: Prompt,

}

#[derive(Debug)]

pub enum ComponentCreationError {

    ModuleDoesntExist,

    DefinitionDoesntExist,

    DefinitionNotComponent,

    InvalidNumArguments,

    InvalidArgumentType(usize),

    UnownedPort,

    InSync,

}

impl ProtocolDescription {

    pub fn parse(buffer: &[u8]) -> Result<Self, String> {

        let source = InputSource::new(String::new(), Vec::from(buffer));

        let mut parser = Parser::new()?;

        parser.feed(source).expect("failed to feed source");

#[macro_use] mod visitor;

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

pub(crate) mod pass_typing;

pub(crate) mod pass_stack_size;

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 pass_rewriting::PassRewriting;

use pass_stack_size::PassStackSize;

use symbol_table::*;

use type_table::*;

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

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

use crate::protocol::parser::type_table::PolymorphicVariable;

const REOWOLF_PATH_ENV: &'static str = "REOWOLF_ROOT"; // first lookup reowolf path

const REOWOLF_PATH_DIR: &'static str = "std"; // then try folder in current working directory

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

    Typed,                  // Type inference and checking has been performed

    Rewritten,              // Special AST nodes are rewritten into regular AST nodes

    // When we continue with the compiler:

    // StackSize

}

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,

}

pub struct TargetArch {

    pub void_type_id: TypeId,

    pub message_type_id: TypeId,

    pub bool_type_id: TypeId,

    pub uint8_type_id: TypeId,

    pub uint16_type_id: TypeId,

    pub uint32_type_id: TypeId,

    pub uint64_type_id: TypeId,

    pub sint8_type_id: TypeId,

    pub sint16_type_id: TypeId,

    pub sint32_type_id: TypeId,

    pub sint64_type_id: TypeId,

    pub char_type_id: TypeId,

    pub string_type_id: TypeId,

    pub array_type_id: TypeId,

    pub slice_type_id: TypeId,

    pub input_type_id: TypeId,

    pub output_type_id: TypeId,

    pub pointer_type_id: TypeId,

}

impl TargetArch {

    fn new() -> Self {

        return Self{

            void_type_id: TypeId::new_invalid(),

            bool_type_id: TypeId::new_invalid(),

            message_type_id: TypeId::new_invalid(),

            uint8_type_id: TypeId::new_invalid(),

            uint16_type_id: TypeId::new_invalid(),

            uint32_type_id: TypeId::new_invalid(),

            uint64_type_id: TypeId::new_invalid(),

            sint8_type_id: TypeId::new_invalid(),

            sint16_type_id: TypeId::new_invalid(),

            sint32_type_id: TypeId::new_invalid(),

            sint64_type_id: TypeId::new_invalid(),

            char_type_id: TypeId::new_invalid(),

            string_type_id: TypeId::new_invalid(),

            array_type_id: TypeId::new_invalid(),

            slice_type_id: TypeId::new_invalid(),

            input_type_id: TypeId::new_invalid(),

            output_type_id: TypeId::new_invalid(),

            pointer_type_id: TypeId::new_invalid(),

        }

    }

}

pub struct PassCtx<'a> {

    heap: &'a mut Heap,

    symbols: &'a mut SymbolTable,

    pool: &'a mut StringPool,

    arch: &'a TargetArch,

}

pub struct Parser {

    // Storage of all information created/gathered during compilation.

    pub(crate) heap: Heap,

    pub(crate) string_pool: StringPool, // Do not deallocate, holds all strings

    pub(crate) modules: Vec<Module>,

    pub(crate) symbol_table: SymbolTable,

    pub(crate) type_table: TypeTable,

    // Compiler passes, used as little state machine that keep their memory

    // around.

    pass_tokenizer: PassTokenizer,

    pass_symbols: PassSymbols,

    pass_import: PassImport,

    pass_definitions: PassDefinitions,

    pass_validation: PassValidationLinking,

    pass_typing: PassTyping,

    pass_rewriting: PassRewriting,

    pass_stack_size: PassStackSize,

    // Compiler options

    pub write_ast_to: Option<String>,

    pub(crate) arch: TargetArch,

}

impl Parser {

    pub fn new() -> Result<Self, String> {

        let mut parser = Parser{

            heap: Heap::new(),

            string_pool: StringPool::new(),

            modules: Vec::new(),

            symbol_table: SymbolTable::new(),

            type_table: TypeTable::new(),

            pass_tokenizer: PassTokenizer::new(),

            pass_symbols: PassSymbols::new(),

            pass_import: PassImport::new(),

            pass_definitions: PassDefinitions::new(),

            pass_validation: PassValidationLinking::new(),

            pass_typing: PassTyping::new(),

            pass_rewriting: PassRewriting::new(),

            pass_stack_size: PassStackSize::new(),

            write_ast_to: None,

            arch: TargetArch::new(),

        };

        parser.symbol_table.insert_scope(None, SymbolScope::Global);

        // Insert builtin types

        // TODO: At some point use correct values for size/alignment

        parser.arch.void_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Void], false, 0, 1);

        parser.arch.message_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Message], false, 24, 8);

        parser.arch.bool_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Bool], false, 1, 1);

        parser.arch.uint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt8], false, 1, 1);

        parser.arch.uint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt16], false, 2, 2);

        parser.arch.uint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt32], false, 4, 4);

        parser.arch.uint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt64], false, 8, 8);

        parser.arch.sint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt8], false, 1, 1);

        parser.arch.sint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt16], false, 2, 2);

        parser.arch.sint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt32], false, 4, 4);

        parser.arch.sint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt64], false, 8, 8);

        parser.arch.char_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Character], false, 4, 4);

        parser.arch.string_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::String], false, 24, 8);

        parser.arch.array_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Array, ConcreteTypePart::Void], true, 24, 8);

        parser.arch.slice_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Slice, ConcreteTypePart::Void], true, 16, 4);

        parser.arch.input_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Input, ConcreteTypePart::Void], true, 8, 8);

        parser.arch.output_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Output, ConcreteTypePart::Void], true, 8, 8);

        parser.arch.pointer_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Pointer, ConcreteTypePart::Void], true, 8, 8);

        parser.feed_standard_library()?;

        return Ok(parser)

    }

        let mut token_buffer = TokenBuffer::new();

        self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;

        let module = Module{

            source,

            tokens: token_buffer,

            root_id: RootId::new_invalid(),

            name: None,

            version: None,

            phase: ModuleCompilationPhase::Tokenized,

        };

        self.modules.push(module);

    }

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

        let mut pass_ctx = PassCtx{

            heap: &mut self.heap,

            symbols: &mut self.symbol_table,

            pool: &mut self.string_pool,

            arch: &self.arch,

        };

        // Advance all modules to the phase where all symbols are scanned

        for module_idx in 0..self.modules.len() {

            self.pass_symbols.parse(&mut self.modules, module_idx, &mut pass_ctx)?;

        }

        // With all symbols scanned, perform further compilation until we can

        // add all base types to the type table.

        for module_idx in 0..self.modules.len() {

            self.pass_import.parse(&mut self.modules, module_idx, &mut pass_ctx)?;

            self.pass_definitions.parse(&mut self.modules, module_idx, &mut pass_ctx)?;

        }

        // Add every known type to the type table

        self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;

        // Continue compilation with the remaining phases now that the types

        // are all in the type table

        for module_idx in 0..self.modules.len() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_validation.visit_module(&mut ctx)?;

        }

        // Perform typechecking on all modules

        let mut queue = ResolveQueue::new();

        for module_idx in 0..self.modules.len() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_rewriting.visit_module(&mut ctx)?;

            self.pass_stack_size.visit_module(&mut ctx)?;

        }

        // Write out desired information

        if let Some(filename) = &self.write_ast_to {

            let mut writer = ASTWriter::new();

            let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();

            writer.write_ast(&mut file, &self.heap);

        }

        Ok(())

    }

    /// Tries to find the standard library and add the files for parsing.

    fn feed_standard_library(&mut self) -> Result<(), String> {

        use std::env;

        use std::path::{Path, PathBuf};

        use std::fs;

        const FILES: [&'static str; 1] = [

            "std.global.pdl",

        ];

        // Determine base directory

        let (base_path, from_env) = if let Ok(path) = env::var(REOWOLF_PATH_ENV) {

            // Path variable is set

            (path, true)

        } else {

            let mut path = String::with_capacity(REOWOLF_PATH_DIR.len() + 2);

            path.push_str("./");

            path.push_str(REOWOLF_PATH_DIR);

            (path, false)

        };

        // Make sure directory exists

        let path = Path::new(&base_path);

        if !path.exists() {

            return Err(format!("std lib root directory '{}' does not exist", base_path));

        }

        // Try to load all standard library files. We might need a more unified

        // way to do this in the future (i.e. a "std" package, containing all

        // of the modules)

        let mut file_path = PathBuf::new();

        for file in FILES {

            file_path.push(path);

            file_path.push(file);

            let source = fs::read(file_path.as_path());

            if let Err(err) = source {

                return Err(format!(

                    "failed to read std lib file '{}' in root directory '{}', because: {}",

                    file, base_path, err

                ));

            }

            let source = source.unwrap();

            let input_source = InputSource::new(file.to_string(), source);

                // A bit of a hack, but shouldn't really happen anyway: the

                // compiler should ship with a decent standard library (at some

                // point)

                return Err(format!("{}", err));

            }

        }

        return Ok(())

    }

}

fn insert_builtin_type(type_table: &mut TypeTable, parts: Vec<ConcreteTypePart>, has_poly_var: bool, size: usize, alignment: usize) -> TypeId {

    const POLY_VARS: [PolymorphicVariable; 1] = [PolymorphicVariable{

        identifier: Identifier::new_empty(InputSpan::new()),

        is_in_use: false,

    }];

    let concrete_type = ConcreteType{ parts };

    let poly_var = if has_poly_var {

        POLY_VARS.as_slice()

    } else {

        &[]

    };

    return type_table.add_builtin_data_type(concrete_type, poly_var, size, alignment);

}

        consume_comma_separated(

            TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,

            |source, iter, ctx| {

                let identifier = consume_ident_interned(source, iter, ctx)?;

                let mut close_pos = identifier.span.end;

                let mut types_section = self.parser_types.start_section();

                let has_embedded = maybe_consume_comma_separated(

                    TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,

                    |source, iter, ctx| {

                        let poly_vars = ctx.heap[definition_id].poly_vars();

                        self.type_parser.consume_parser_type(

                            iter, &ctx.heap, source, &ctx.symbols, poly_vars, definition_id,

                            module_scope, false, None

                        )

                    },

                    &mut types_section, "an embedded type", Some(&mut close_pos)

                )?;

                let value = if has_embedded {

                    types_section.into_vec()

                } else {

                    types_section.forget();

                    Vec::new()

                };

                Ok(UnionVariantDefinition{

                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

                    identifier,

                    value

                })

            },

            &mut variants_section, "a union variant", "a list of union variants", None

        )?;

        // Transfer to AST

        let union_def = ctx.heap[definition_id].as_union_mut();

        union_def.variants = variants_section.into_vec();

        Ok(())

    }

    fn visit_function_definition(

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

    ) -> Result<(), ParseError> {

        // Retrieve function name

        consume_exact_ident(&module.source, iter, KW_FUNCTION)?;

        let (ident_text, _) = consume_ident(&module.source, iter)?;

        // Retrieve preallocated DefinitionId

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        self.cur_definition = definition_id;

        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

        // Parse function's argument list

        let mut parameter_section = self.variables.start_section();

        consume_parameter_list(

            &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

        )?;

        let parameters = parameter_section.into_vec();

        // Consume return types

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

        let poly_vars = ctx.heap[definition_id].poly_vars();

        let parser_type = self.type_parser.consume_parser_type(

            iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, definition_id,

            module_scope, false, None

        )?;

        // Consume body

        let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, ProcedureKind::Function)?;

        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));

        // Assign everything in the preallocated AST node

        let function = ctx.heap[definition_id].as_procedure_mut();

        function.source = source;

        function.return_type = Some(parser_type);

        function.parameters = parameters;

        function.scope = scope_id;

        function.body = body_id;

        Ok(())

    }

    fn visit_component_definition(

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

    ) -> Result<(), ParseError> {

        // Consume component variant and name

        let (_variant_text, _) = consume_any_ident(&module.source, iter)?;

        debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);

        let (ident_text, _) = consume_ident(&module.source, iter)?;

        // Retrieve preallocated definition

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        self.cur_definition = definition_id;

        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

        // Parse component's argument list

        let mut parameter_section = self.variables.start_section();

        consume_parameter_list(

            &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

        )?;

        let parameters = parameter_section.into_vec();

        // Consume body

        let procedure_kind = ctx.heap[definition_id].as_procedure().kind;

        let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, procedure_kind)?;

        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));

        // Assign everything in the AST node

        let component = ctx.heap[definition_id].as_procedure_mut();

        debug_assert!(component.return_type.is_none());

        component.source = source;

        component.parameters = parameters;

        component.scope = scope_id;

        component.body = body_id;

        Ok(())

    }

    /// Consumes a procedure's body: either a user-defined procedure, which we

    /// parse as normal, or a builtin function, where we'll make sure we expect

    /// the particular builtin.

    ///

    /// We expect that the procedure's name is already stored in the

    /// preallocated AST node.

    fn consume_procedure_body(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, definition_id: DefinitionId, kind: ProcedureKind

    ) -> Result<(BlockStatementId, ProcedureSource), ParseError> {

            let (pragma, pragma_start, pragma_end) = consume_pragma(&module.source, iter)?;

            if pragma != b"#builtin" {

                return Err(ParseError::new_error_str_at_span(

                    &module.source, InputSpan::from_positions(pragma_start, pragma_end),

                    "expected a '#builtin' pragma, or a function body"

                ));

            }

            // Retrieve module and procedure name

            assert!(module.name.is_some(), "compiler error: builtin procedure body in unnamed module");

            let (_, module_name) = module.name.as_ref().unwrap();

            let module_name = module_name.as_str();

            let definition = ctx.heap[definition_id].as_procedure();

            let procedure_name = definition.identifier.value.as_str();

            let source = match (module_name, procedure_name) {

                ("std.global", "get") => ProcedureSource::FuncGet,

                ("std.global", "put") => ProcedureSource::FuncPut,

                ("std.global", "fires") => ProcedureSource::FuncFires,

                ("std.global", "create") => ProcedureSource::FuncCreate,

                ("std.global", "length") => ProcedureSource::FuncLength,

                ("std.global", "assert") => ProcedureSource::FuncAssert,

                ("std.global", "print") => ProcedureSource::FuncPrint,

                _ => panic!(

                    "compiler error: unknown builtin procedure '{}' in module '{}'",

                    procedure_name, module_name

                ),

            };

            return Ok((BlockStatementId::new_invalid(), source));

        } else {

            let body_id = self.consume_block_statement(module, iter, ctx)?;

            let source = match kind {

                ProcedureKind::Function =>

                    ProcedureSource::FuncUserDefined,

                ProcedureKind::Primitive | ProcedureKind::Composite =>

                    ProcedureSource::CompUserDefined,

            };

            return Ok((body_id, source))

        }

    }

    /// Consumes a statement and returns a boolean indicating whether it was a

    /// block or not.

    fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {

        let next = iter.next().expect("consume_statement has a next token");

        if next == TokenKind::OpenCurly {

            let id = self.consume_block_statement(module, iter, ctx)?;

            return Ok(id.upcast());

        } else if next == TokenKind::Ident {

            let ident = peek_ident(&module.source, iter).unwrap();

            if ident == KW_STMT_IF {

                // Consume if statement and place end-if statement directly

                    &this_module.source, pragma_span, "conflict in module name"

                ).with_info_str_at_span(

                    &other_module.source, other_pragma.span, "other module is defined here"

                ));

            }

            module.name = Some((pragma_id, module_name));

            self.has_pragma_module = true;

        } else if pragma_section == b"#version" {

            // Check if version is defined twice within the same file

            if self.has_pragma_version {

                return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "module version is defined twice"));

            }

            // Consume the version pragma

            let (version, version_span) = consume_integer_literal(&module.source, &mut iter, &mut self.buffer)?;

            let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Version(PragmaVersion{

                this,

                span: InputSpan::from_positions(pragma_start, version_span.end),

                version,

            }));

            self.pragmas.push(pragma_id);

            module.version = Some((pragma_id, version as i64));

            self.has_pragma_version = true;

        } else {

            // Custom pragma, maybe we support this in the future, but for now

            // we don't.

            return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "illegal pragma name"));

        }

        Ok(())

    }

    fn visit_definition_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {

        let module = &modules[module_idx];

        let range = &module.tokens.ranges[range_idx];

        let definition_span = InputSpan::from_positions(

            module.tokens.start_pos(range),

            module.tokens.end_pos(range)

        );

        let mut iter = module.tokens.iter_range(range);

        // First ident must be type of symbol

        let (kw_text, _) = consume_any_ident(&module.source, &mut iter).unwrap();

        // Retrieve identifier of definition

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

        let mut poly_vars = Vec::new();

        maybe_consume_comma_separated(

            TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter, ctx,

            |source, iter, ctx| consume_ident_interned(source, iter, ctx),

            &mut poly_vars, "a polymorphic variable", None

        )?;

        let ident_text = identifier.value.clone(); // because we need it later

        let ident_span = identifier.span.clone();

        // Reserve space in AST for definition and add it to the symbol table

        let definition_class;

        let ast_definition_id;

        match kw_text {

            KW_STRUCT => {

                let struct_def_id = ctx.heap.alloc_struct_definition(|this| {

                    StructDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Struct;

                ast_definition_id = struct_def_id.upcast();

            },

            KW_ENUM => {

                let enum_def_id = ctx.heap.alloc_enum_definition(|this| {

                    EnumDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Enum;

                ast_definition_id = enum_def_id.upcast();

            },

            KW_UNION => {

                let union_def_id = ctx.heap.alloc_union_definition(|this| {

                    UnionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Union;

                ast_definition_id = union_def_id.upcast()

            },

            KW_FUNCTION => {

                let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {

                    ProcedureDefinition::new_empty(this, module.root_id, definition_span, ProcedureKind::Function, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Function;

                ast_definition_id = proc_def_id.upcast();

            },

            KW_PRIMITIVE | KW_COMPOSITE => {

                let procedure_kind = if kw_text == KW_PRIMITIVE {

                    ProcedureKind::Primitive

                } else {

                    ProcedureKind::Composite

                };

                let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {

        ));

    }

    Ok(pos)

}

/// Consumes an identifier that is not a reserved keyword and returns it

/// together with its span.

pub(crate) fn consume_ident<'a>(

    source: &'a InputSource, iter: &mut TokenIter

) -> Result<(&'a [u8], InputSpan), ParseError> {

    let (ident, span) = consume_any_ident(source, iter)?;

    if is_reserved_keyword(ident) {

        return Err(ParseError::new_error_str_at_span(source, span, "encountered reserved keyword"));

    }

    Ok((ident, span))

}

/// Consumes an identifier and immediately intern it into the `StringPool`

pub(crate) fn consume_ident_interned(

    source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx

) -> Result<Identifier, ParseError> {

    let (value, span) = consume_ident(source, iter)?;

    let value = ctx.pool.intern(value);

    Ok(Identifier{ span, value })

}

fn is_reserved_definition_keyword(text: &[u8]) -> bool {

    match text {

        KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_PRIMITIVE | KW_COMPOSITE => true,

        _ => false,

    }

}

fn is_reserved_statement_keyword(text: &[u8]) -> bool {

    match text {

        KW_IMPORT | KW_AS |

        KW_STMT_CHANNEL | KW_STMT_IF | KW_STMT_WHILE |

        KW_STMT_BREAK | KW_STMT_CONTINUE | KW_STMT_GOTO | KW_STMT_RETURN |

        KW_STMT_SYNC | KW_STMT_FORK | KW_STMT_NEW => true,

        _ => false,

    }

}

fn is_reserved_expression_keyword(text: &[u8]) -> bool {

    match text {

        KW_LET | KW_CAST |

        KW_LIT_TRUE | KW_LIT_FALSE | KW_LIT_NULL |

        _ => false,

    }

}

fn is_reserved_type_keyword(text: &[u8]) -> bool {

    match text {

        KW_TYPE_IN_PORT | KW_TYPE_OUT_PORT | KW_TYPE_MESSAGE | KW_TYPE_BOOL |

        KW_TYPE_UINT8 | KW_TYPE_UINT16 | KW_TYPE_UINT32 | KW_TYPE_UINT64 |

        KW_TYPE_SINT8 | KW_TYPE_SINT16 | KW_TYPE_SINT32 | KW_TYPE_SINT64 |

        KW_TYPE_CHAR | KW_TYPE_STRING |

        KW_TYPE_INFERRED => true,

        _ => false,

    }

}

fn is_reserved_keyword(text: &[u8]) -> bool {

    return

        is_reserved_definition_keyword(text) ||

        is_reserved_statement_keyword(text) ||

        is_reserved_expression_keyword(text) ||

        is_reserved_type_keyword(text);

}

pub(crate) fn seek_module(modules: &[Module], root_id: RootId) -> Option<&Module> {

    for module in modules {

        if module.root_id == root_id {

            return Some(module)

        }

    }

    return None

}

/// Constructs a human-readable message indicating why there is a conflict of

/// symbols.

// Note: passing the `module_idx` is not strictly necessary, but will prevent

// programmer mistakes during development: we get a conflict because we're

// currently parsing a particular module.

pub(crate) fn construct_symbol_conflict_error(

    modules: &[Module], module_idx: usize, ctx: &PassCtx, new_symbol: &Symbol, old_symbol: &Symbol

) -> ParseError {

    let module = &modules[module_idx];

    let get_symbol_span_and_msg = |symbol: &Symbol| -> (String, Option<InputSpan>) {

        match &symbol.variant {

            SymbolVariant::Module(module) => {

                let import = &ctx.heap[module.introduced_at];

                return (

                    format!("the module aliased as '{}' imported here", symbol.name.as_str()),

                    Some(import.as_module().span)

                );

            },

            SymbolVariant::Definition(definition) => {

                if definition.defined_in_module.is_invalid() {

                    // Must be a builtin thing

                    return (format!("the builtin '{}'", symbol.name.as_str()), None)

                } else {

                    if let Some(import_id) = definition.imported_at {

                        let import = &ctx.heap[import_id];

                        return (

                            format!("the type '{}' imported here", symbol.name.as_str()),

                            Some(import.as_symbols().span)

                        );

                        return (

                            format!("the type '{}' defined here", symbol.name.as_str()),

                            Some(definition.identifier_span)

                        )

                    }

                }

            }

        }

    };

    let (new_symbol_msg, new_symbol_span) = get_symbol_span_and_msg(new_symbol);

    let (old_symbol_msg, old_symbol_span) = get_symbol_span_and_msg(old_symbol);

    let new_symbol_span = new_symbol_span.unwrap(); // because new symbols cannot be builtin