// Validator/linker

    pub parent: ExpressionParent,

    // Typing

    pub type_index: 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 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,

        }

    }

}

#[derive(Debug, Clone)]

pub struct LiteralExpression {

    pub this: LiteralExpressionId,

    // Parsing

    pub span: InputSpan,

    pub value: Literal,

    // Validator/Linker

    pub parent: ExpressionParent,

    // Typing

    pub type_index: i32,

}

                                Method::SelectStart => {

                                    let num_cases = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let num_ports = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    return Ok(EvalContinuation::SelectStart(num_cases, num_ports));

                                },

                                Method::SelectRegisterCasePort => {

                                    let case_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_value = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_port_id();

                                    return Ok(EvalContinuation::SelectRegisterPort(case_index, port_index, port_value));

                                },

                                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

                                    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

                                    let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];

                                    let (type_id, monomorph_index) = mono_data.expr_info[expr.type_index as usize].variant.as_procedure();

                                    // Push the new frame and reserve its stack size

                                    let new_frame = Frame::new(heap, expr.procedure, type_id, monomorph_index);

                symbols: &mut self.symbol_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;

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

        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 input_source = InputSource::new(file.to_string(), source);

            let module_index = self.feed_internal(input_source, true);

            if let Err(err) = module_index {

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

            }

            let module_index = module_index.unwrap();

            if first_file {

            }

            if iter.next() != Some(TokenKind::CloseCurly) {

                // Just to keep the compiler writers in line ;)

                panic!("compiler error: when using the #builtin pragma, wrap it in curly braces");

            }

            iter.consume();

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

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

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

        Ok(ctx.heap.alloc_goto_statement(|this| GotoStatement{

            this,

            span: goto_span,

            label,

            target: LabeledStatementId::new_invalid(),

        }))

    }

    fn consume_new_statement(

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

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

            span: new_span,

            expression: call_id,

            next: StatementId::new_invalid(),

        }))

    }

    fn consume_channel_statement(

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

    ) -> Result<ChannelStatementId, ParseError> {

        // Consume channel specification

        let channel_span = consume_exact_ident(&module.source, iter, KW_STMT_CHANNEL)?;

        let (inner_port_type, end_pos) = if Some(TokenKind::OpenAngle) == iter.next() {

                                    span: InputSpan::from_positions(ident_span.begin, end_pos),

                                    value: Literal::Union(LiteralUnion{

                                        parser_type, variant, values,

                                        definition: target_definition_id,

                                        variant_idx: 0,

                                    }),

                                    parent: ExpressionParent::None,

                                    type_index: -1,

                                }).upcast()

                            },

                            Definition::Procedure(proc_def) => {

                                // Check whether it is a builtin function

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

                                    parent: ExpressionParent::None,

                                    type_index: -1,

                                }).upcast()

                            }

                        }

                    },

                    _ => {

                        return Err(ParseError::new_error_str_at_span(

                            &module.source, parser_type.full_span, "unexpected type in expression"

                        ))

                    }

                }

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

            return (span, name);

        }

        if expecting_primitive_def {

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

                ));

            }

        }

                    embedded.size = size;

                    embedded.alignment = alignment;

                    size_alignment_idx += 1;

                    align_offset_to(&mut variant_offset, alignment);

                    embedded.alignment = variant_offset;

                    variant_offset += size;

                    variant_alignment = variant_alignment.max(alignment);

                }

                max_size = max_size.max(variant_offset);

                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,

    ) -> MemoryLayoutResult {

        use ConcreteTypePart as CTP;

        debug_assert!(!parts.is_empty());

        let type_id = match parts[0] {

            CTP::Void      => arch.void_type_id,

            CTP::Message   => arch.message_type_id,

            CTP::Bool      => arch.bool_type_id,

            CTP::UInt8     => arch.uint8_type_id,

            CTP::UInt16    => arch.uint16_type_id,

            CTP::UInt32    => arch.uint32_type_id,

            CTP::UInt64    => arch.uint64_type_id,

        u32 index = 0;

        while (index < 5) {

            sync select { auto v = () -> index += 1; }

        }

    }

    ").expect("compilation");

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

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

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

}

#[test]

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 }