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

    pub method: Method,

    pub arguments: Vec<ExpressionId>,

    pub procedure: ProcedureDefinitionId,

    // Validator/Linker

    pub parent: ExpressionParent,

    // Typing

    pub type_index: i32,

}

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

pub enum Method {

    Get,

    Put,

    Fires,

    Create,

    Length,

    Assert,

    Print,

    SelectStart, // SelectStart(total_num_cases, total_num_ports)

    SelectRegisterCasePort, // SelectRegisterCasePort(case_index, port_index, port_id)

    SelectWait, // SelectWait() -> u32

    // User-defined

    UserFunction,

    UserComponent,

}

impl Method {

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

        use Method::*;

        match self {

            Get | Put | Fires | Create | Length | Assert | Print => true,

            _ => false,

        }

    }

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

        use Method::*;

        match self {

            UserFunction | UserComponent => true,

            _ => false,

        }

    }

}

                                },

                                Method::SelectWait => {

                                    match ctx.performed_select_wait() {

                                        Some(select_index) => {

                                            cur_frame.expr_values.push_back(Value::UInt32(select_index));

                                        },

                                        None => {

                                            cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr.this.upcast()));

                                            return Ok(EvalContinuation::SelectWait)

                                        },

                                    }

                                },

                                Method::UserComponent => {

                                    // This is actually handled by the evaluation

                                    // of the statement.

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

                                },

                                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

            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;

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

        };

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

        let mut first_file = true;

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

    ) -> Result<NewStatementId, ParseError> {

        let new_span = consume_exact_ident(&module.source, iter, KW_STMT_NEW)?;

        let start_pos = iter.last_valid_pos();

        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 {

            // Allow both components and functions, as it makes more sense to

            // check their correct use in the validation and linking pass

        }

        if !valid {

            return Err(ParseError::new_error_str_at_span(

                &module.source, InputSpan::from_positions(start_pos, iter.last_valid_pos()), "expected a call expression"

            ));

        }

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

        debug_assert!(!call_id.is_invalid());

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

            this,

                                // TODO: Once we start generating bytecode this is unnecessary

                                let procedure_id = proc_def.this;

                                let method = match proc_def.source {

                                    ProcedureSource::FuncUserDefined => Method::UserFunction,

                                    ProcedureSource::CompUserDefined => Method::UserComponent,

                                    ProcedureSource::FuncGet => Method::Get,

                                    ProcedureSource::FuncPut => Method::Put,

                                    ProcedureSource::FuncFires => Method::Fires,

                                    ProcedureSource::FuncCreate => Method::Create,

                                    ProcedureSource::FuncLength => Method::Length,

                                    ProcedureSource::FuncAssert => Method::Assert,

                                    ProcedureSource::FuncPrint => Method::Print,

                                };

                                // Function call: consume the arguments

                                let func_span = parser_type.full_span;

                                let mut full_span = func_span;

                                let arguments = self.consume_expression_list(

                                    module, iter, ctx, Some(&mut full_span.end)

                                )?;

                                ctx.heap.alloc_call_expression(|this| CallExpression{

                                    this, func_span, full_span, parser_type, method, arguments,

                                    procedure: procedure_id,

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

                max_alignment = max_alignment.max(variant_alignment);

            }

            if max_size != 0 {

                // At least one entry lives on the heap

                mono_type.heap_size = max_size;

                mono_type.heap_alignment = max_alignment;

            }

        }

        // And now, we're actually, properly, done

        self.encountered_types.clear();

    }

    /// Attempts to compute size/alignment for the provided type. Note that this

    /// is called *after* type loops have been succesfully resolved. Hence we

    /// may assume that all monomorph entries exist, but we may not assume that

    /// those entries already have their size/alignment computed.

    // Passed parameters are messy. But need to strike balance between borrowing

    // and allocations in hot loops. So it is what it is.

    fn get_memory_layout_or_breadcrumb(

        definition_map: &DefinitionMap, mono_type_map: &MonoTypeMap, mono_types: &MonoTypeArray,

        search_key: &mut MonoSearchKey, arch: &TargetArch, parts: &[ConcreteTypePart],

        size_alignment_stack_len: usize,

fn test_empty_select() {

    let pd = ProtocolDescription::parse(b"

    primitive constructor() {

        u32 index = 0;

        while (index < 5) {

            sync select {}

            index += 1;

        }

    }

    ").expect("compilation");

    let rt = Runtime::new(3, false, pd);

    create_component(&rt, "", "constructor", no_args());

}

#module std.global

func get<T>(in<T> input) -> T { #builtin }

func put<T>(out<T> output, T value) -> #type_void { #builtin }

func fires<T>(#type_portlike<T> port) -> bool { #builtin }

func create<T>(#type_integerlike len) -> T[] { #builtin }

func length<T>(#type_arraylike<T> array) -> u32 { #builtin }

func assert(bool condition) -> #type_void { #builtin }

func print(string message) -> #type_void { #builtin }