impl UnionDefinition {

    pub(crate) fn new_empty(

        this: UnionDefinitionId, defined_in: RootId,

        identifier: Identifier, poly_vars: Vec<Identifier>

    ) -> Self {

        Self{ this, defined_in, identifier, poly_vars, variants: Vec::new() }

    }

}

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

pub enum ProcedureKind {

    Function, // with return type

}

/// Monomorphed instantiation of a procedure (or the sole instantiation of a

/// non-polymorphic procedure).

#[derive(Debug)]

pub struct ProcedureDefinitionMonomorph {

    pub argument_types: Vec<TypeId>,

    pub expr_info: Vec<ExpressionInfo>

}

impl ProcedureDefinitionMonomorph {

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

            let next = iter.next();

            if next.is_none() {

                return Ok(())

            }

            // Token was not None, so peek_ident returns None if not an ident

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

            match ident {

                Some(KW_STRUCT) => self.visit_struct_definition(module, &mut iter, ctx)?,

                Some(KW_ENUM) => self.visit_enum_definition(module, &mut iter, ctx)?,

                Some(KW_UNION) => self.visit_union_definition(module, &mut iter, ctx)?,

                Some(KW_FUNCTION) => self.visit_function_definition(module, &mut iter, ctx)?,

                _ => return Err(ParseError::new_error_str_at_pos(

                    &module.source, iter.last_valid_pos(),

                    "unexpected symbol, expected a keyword marking the start of a definition"

                )),

            }

        }

    }

    fn visit_struct_definition(

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

    ) -> Result<(), ParseError> {

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

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

        let allow_compiler_types = module.is_compiler_file;

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

        // Parse component's argument list

                _ => 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,

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

                    UnionDefinition::new_empty(this, module.root_id, 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, ProcedureKind::Function, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Function;

                ast_definition_id = proc_def_id.upcast();

            },

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

                });

                definition_class = DefinitionClass::Component;

                ast_definition_id = proc_def_id.upcast();

            },

            _ => unreachable!("encountered keyword '{}' in definition range", String::from_utf8_lossy(kw_text)),

        }

        let symbol = Symbol{

            name: ident_text,

            variant: SymbolVariant::Definition(SymbolDefinition{

                defined_in_module: module.root_id,

                defined_in_scope: SymbolScope::Module(module.root_id),

            },

        }

    }

}

// Helpers for characters

fn demarks_symbol(ident: &[u8]) -> bool {

    return

        ident == KW_STRUCT ||

            ident == KW_ENUM ||

            ident == KW_UNION ||

            ident == KW_FUNCTION ||

}

#[inline]

fn demarks_import(ident: &[u8]) -> bool {

    return ident == KW_IMPORT;

}

#[inline]

fn is_whitespace(c: u8) -> bool {

    c.is_ascii_whitespace()

}

        let scope_id = sync_stmt.scope;

        if !self.in_sync.is_invalid() {

            // Nested synchronous statement

            let old_sync_span = ctx.heap[self.in_sync].span;

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, cur_sync_span, "Illegal nested synchronous statement"

            ).with_info_str_at_span(

                &ctx.module().source, old_sync_span, "It is nested in this synchronous statement"

            ));

        }

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, cur_sync_span,

            ));

        }

        // Synchronous statement implicitly moves to its block

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

        // Visit block statement. Note that we explicitly push the scope here

        // (and the `visit_block_stmt` will also push, but without effect) to

        // ensure the scope contains the sync ID.

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

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

        self.in_sync = id;

        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"

            ));

        }

            return Err(ParseError::new_error_str_at_span(

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

            ));

        }

        // Visit the various arms in the select block

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

        let mut case_scope_ids = self.scope_buffer.start_section();

        let num_cases = select_stmt.cases.len();

        for case in &select_stmt.cases {

            // We add them in pairs, so the subsequent for-loop retrieves in pairs

            case_stmt_ids.push(case.guard);

            case_stmt_ids.push(case.body);

            case_scope_ids.push(case.scope);

        self.control_flow_stmts.push(ControlFlowStatement{

            in_sync: self.in_sync,

            in_while: self.in_while,

            in_scope: self.cur_scope,

            statement: id.upcast(),

        });

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

        Ok(())

    }

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

            let new_stmt = &ctx.heap[id];

            return Err(ParseError::new_error_str_at_span(

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

            ));

        }

        // Recurse into call expression (which will check the expression parent

        // to ensure that the "new" statment instantiates a component)

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

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

        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;

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

        let call_expr = &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 call expression"

            ))

        }

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

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

        let mut expecting_wrapping_new_stmt = false;

        let mut expecting_wrapping_sync_stmt = false;

        let mut expecting_no_select_stmt = false;

        match call_expr.method {

            Method::Get => {

                expecting_wrapping_sync_stmt = true;

                if !self.in_select_guard.is_invalid() {

                    // In a select guard. Take the argument (i.e. the port we're

                    // retrieving from) and add it to the list of involved ports

                    // of the guard

                    if call_expr.arguments.len() == 1 {

                        // We're checking the number of arguments later, for now

                        // assume it is correct.

                        let argument = call_expr.arguments[0];

                        let select_stmt = &mut ctx.heap[self.in_select_guard];

                        let select_case = &mut select_stmt.cases[self.in_select_arm as usize];

                        select_case.involved_ports.push((id, argument));

                    }

                }

            },

            Method::Put => {

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

            },

            Method::Fires => {

                expecting_wrapping_sync_stmt = true;

            },

            Method::Create => {},

            Method::Length => {},

            Method::Assert => {

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

                if self.proc_kind == ProcedureKind::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"

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

            if self.in_sync.is_invalid() {

                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 inside synchronous blocks", func_name)

                ))

            }

        }

        if expecting_no_select_stmt {

};

use super::tokens::*;

use super::symbol_table::*;

use super::{Module, PassCtx};

// Keywords

pub(crate) const KW_LET:       &'static [u8] = b"let";

pub(crate) const KW_AS:        &'static [u8] = b"as";

pub(crate) const KW_STRUCT:    &'static [u8] = b"struct";

pub(crate) const KW_ENUM:      &'static [u8] = b"enum";

pub(crate) const KW_UNION:     &'static [u8] = b"union";

pub(crate) const KW_FUNCTION:  &'static [u8] = b"func";

pub(crate) const KW_IMPORT:    &'static [u8] = b"import";

// Keywords - literals

pub(crate) const KW_LIT_TRUE:  &'static [u8] = b"true";

pub(crate) const KW_LIT_FALSE: &'static [u8] = b"false";

pub(crate) const KW_LIT_NULL:  &'static [u8] = b"null";

// Keywords - function(like)s

pub(crate) const KW_CAST:        &'static [u8] = b"cast";

pub(crate) const KW_FUNC_GET:    &'static [u8] = b"get";

pub(crate) const KW_FUNC_PUT:    &'static [u8] = b"put";

pub(crate) const KW_FUNC_FIRES:  &'static [u8] = b"fires";

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

        _ => 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,

    }

pub(crate) type InboxBackup = Vec<DataMessage>;

/// Creates a new component based on its definition. Meaning that if it is a

/// user-defined component then we set up the PDL code state. Otherwise we

/// construct a custom component. This does NOT take care of port and message

/// management.

pub(crate) fn create_component(

    protocol: &ProtocolDescription,

    definition_id: ProcedureDefinitionId, type_id: TypeId,

    arguments: ValueGroup, num_ports: usize

) -> Box<dyn Component> {

    let definition = &protocol.heap[definition_id];

    if definition.source.is_builtin() {

        // Builtin component

        let component: Box<dyn Component> = match definition.source {

            ProcedureSource::CompRandomU32 => Box::new(ComponentRandomU32::new(arguments)),

            ProcedureSource::CompTcpClient => Box::new(ComponentTcpClient::new(arguments)),

            _ => unreachable!(),

        };

        return component;

    } else {

        // User-defined component