#[derive(Debug, Clone)]

pub struct UnionDefinition {

    pub this: UnionDefinitionId,

    pub defined_in: RootId,

    // Phase 1: symbol scanning

    pub identifier: Identifier,

    pub poly_vars: Vec<Identifier>,

    // Phase 2: parsing

    pub variants: Vec<UnionVariantDefinition>,

}

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 {

        return Self{

            argument_types: Vec::new(),

            expr_info: Vec::new(),

        }

    }

}

#[derive(Debug, Clone, Copy)]

pub struct ExpressionInfo {

    pub type_id: TypeId,

    pub variant: ExpressionInfoVariant,

}

        Ok(())

    }

    fn visit_token_range(

        &mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx,

        token_range_begin: u32, token_range_end: u32,

    ) -> Result<(), ParseError> {

        let module = &modules[module_idx];

        // Detect which definition we're parsing

        let mut iter = module.tokens.iter_range(token_range_begin, Some(token_range_end));

        loop {

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

        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;

        // Parse struct definition

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

        let mut fields_section = self.struct_fields.start_section();

        let parser_type = self.type_parser.consume_parser_type(

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

            module_scope, false, allow_compiler_types, 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 (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

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

        )?;

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

            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,

                ("std.random", "random_u32") => ProcedureSource::CompRandomU32,

                ("std.internet", "tcp_client") => ProcedureSource::CompTcpClient,

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

        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

                // after it.

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

                return Ok(id.upcast());

            } else if ident == KW_STMT_WHILE {

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

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

                identifier_span: ident_span,

                imported_at: None,

                class: definition_class,

                definition_id: ast_definition_id,

            }),

        };

        self.symbols.push(symbol);

        self.definitions.push(ast_definition_id);

        Ok(())

    }

}

            last_token: u32::MAX,

            handled: false,

        });

    }

    fn check_ascii(&self, source: &InputSource) -> Result<(), ParseError> {

        match source.next() {

            Some(c) if !c.is_ascii() => {

                Err(ParseError::new_error_str_at_pos(source, source.pos(), "encountered a non-ASCII character"))

            },

            _else => {

                Ok(())

            },

        }

    }

}

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

}

#[inline]

fn is_char_literal_start(c: u8) -> bool {

    return c == b'\'';

}

#[inline]

fn is_bytestring_literal_start(c: u8, source: &InputSource) -> bool {

    return c == b'b' && source.lookahead(1) == Some(b'"');

}

#[inline]

fn is_string_literal_start(c: u8) -> bool {

            statement: id.upcast()

        });

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

        Ok(())

    }

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

        // Check for validity of synchronous statement

        let sync_stmt = &ctx.heap[id];

        let end_sync_id = sync_stmt.end_sync;

        let cur_sync_span = sync_stmt.span;

        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 old_scope = self.push_scope(ctx, false, scope_id);

        self.visit_stmt(ctx, sync_body)?;

        self.pop_scope(old_scope);

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

        self.in_sync = SynchronousStatementId::new_invalid();

        Ok(())

    }

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

            self.visit_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 = &mut ctx.heap[id];

        select_stmt.relative_pos_in_parent = self.relative_pos_in_parent;

        self.relative_pos_in_parent += 1;

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

        }

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

        for index in 0..num_cases {

            let base_index = 2 * index;

            let guard_id     = case_stmt_ids[base_index];

            let case_body_id = case_stmt_ids[base_index + 1];

            let case_scope_id = case_scope_ids[index];

            // The guard statement ends up belonging to the block statement

            // following the arm. The reason we parse it separately is to

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

        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;

        Ok(())

    }

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

        let 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::ExpressionStmt(id);

        self.visit_expr(ctx, expr_id)?;

        self.expr_parent = ExpressionParent::None;

        let old_expr_parent = self.expr_parent;

        cast_expr.parent = old_expr_parent;

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

        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"

                    ));

                }

            },

            Method::Print => {},

            Method::SelectStart

            | Method::SelectRegisterCasePort

            | Method::SelectWait => unreachable!(), // not usable by programmer directly

            Method::ComponentRandomU32

            | Method::ComponentTcpClient => {

                expecting_wrapping_new_stmt = true;

            },

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

            if !self.in_select_guard.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 not occur in a select statement's guard", func_name)

                ));

            }

        }

        if expecting_wrapping_new_stmt {

            if !self.expr_parent.is_new() {

                let call_span = call_expr.func_span;

use crate::collections::ScopedSection;

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

use crate::protocol::input_source::{

    InputSource as InputSource,

    InputPosition as InputPosition,

    InputSpan,

    ParseError,

};

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

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

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

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

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

// Keywords - statements

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

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

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

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

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

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

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

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

            self.mode_port == port;

    }

    pub(crate) fn is_blocked_on_create_component(&self) -> bool {

        return self.mode == CompMode::NewComponentBlocked;

    }

}

// TODO: Replace when implementing port sending. Should probably be incorporated

//  into CompCtx (and rename CompCtx into CompComms)

pub(crate) type InboxMain = Vec<Option<DataMessage>>;

pub(crate) type InboxMainRef = [Option<DataMessage>];

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

        let prompt = Prompt::new(

            &protocol.types, &protocol.heap,

            definition_id, type_id, arguments

        );

        let component = CompPDL::new(prompt, num_ports);

        return Box::new(component);

    }

}

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

// Generic component messaging utilities (for sending and receiving)

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