// String pool cannot be cloned, and the created `StringRef` instances remain

// allocated until the end of the program, so it is always safe to send. It is

// also sync in the sense that it becomes an immutable thing after compilation,

// but lets not derive that if we would ever become a multithreaded compiler in

// the future.

unsafe impl Send for StringPool {}

    module_ptr: *const u8,

    module_len: usize,

        &*slice_from_raw_parts(module_ptr, module_len),

use std::fmt;

use crate::protocol::{

    ast::*,

    Module,

    input_source::{ErrorStatement, StatementKind}

};

use super::executor::*;

/// Represents a stack frame recorded in an error

#[derive(Debug)]

pub struct EvalFrame {

    pub line: u32,

    pub module_name: String,

    pub procedure: String, // function or component

    pub is_func: bool,

}

impl fmt::Display for EvalFrame {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let func_or_comp = if self.is_func {

            "function "

        } else {

            "component"

        };

        if self.module_name.is_empty() {

            write!(f, "{} {}:{}", func_or_comp, &self.procedure, self.line)

        } else {

            write!(f, "{} {}:{}:{}", func_or_comp, &self.module_name, &self.procedure, self.line)

        }

    }

}

/// Represents an error that ocurred during evaluation. Contains error

/// statements just like in parsing errors. Additionally may display the current

/// execution state.

#[derive(Debug)]

pub struct EvalError {

    pub(crate) statements: Vec<ErrorStatement>,

    pub(crate) frames: Vec<EvalFrame>,

}

impl EvalError {

    pub(crate) fn new_error_at_expr(prompt: &Prompt, modules: &[Module], heap: &Heap, expr_id: ExpressionId, msg: String) -> EvalError {

        // Create frames

        debug_assert!(!prompt.frames.is_empty());

        let mut frames = Vec::with_capacity(prompt.frames.len());

        let mut last_module_source = &modules[0].source;

        for frame in prompt.frames.iter() {

            let definition = &heap[frame.definition];

            let statement = &heap[frame.position];

            let statement_span = statement.span();

            let (root_id, procedure, is_func) = match definition {

                Definition::Function(def) => {

                    (def.defined_in, def.identifier.value.as_str().to_string(), true)

                },

                Definition::Component(def) => {

                    (def.defined_in, def.identifier.value.as_str().to_string(), false)

                },

                _ => unreachable!("construct stack frame with definition pointing to data type")

            };

            // Lookup module name, if it has one

            let module = modules.iter().find(|m| m.root_id == root_id).unwrap();

            let module_name = if let Some(name) = &module.name {

                name.as_str().to_string()

            } else {

                String::new()

            };

            last_module_source = &module.source;

            frames.push(EvalFrame{

                line: statement_span.begin.line,

                module_name,

                procedure,

                is_func

            });

        }

        let expr = &heap[expr_id];

        let statements = vec![

            ErrorStatement::from_source_at_span(StatementKind::Error, last_module_source, expr.span(), msg)

        ];

        EvalError{ statements, frames }

    }

}

impl fmt::Display for EvalError {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        // Display error statement(s)

        self.statements[0].fmt(f)?;

        for statement in self.statements.iter().skip(1) {

            writeln!(f)?;

            statement.fmt(f)?;

        }

        // Display stack trace

        writeln!(f)?;

        writeln!(f, " +-  Stack trace:")?;

        for frame in self.frames.iter().rev() {

            write!(f, " | ")?;

            frame.fmt(f)?;

            writeln!(f)?;

        }

        Ok(())

    }

}

use super::error::*;

    pub(crate) definition: DefinitionId,

    pub(crate) position: StatementId,

    pub(crate) expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back

    pub(crate) expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back

type EvalResult = Result<EvalContinuation, EvalError>;

    pub(crate) fn step(&mut self, heap: &Heap, modules: &[Module], ctx: &mut EvalContext) -> EvalResult {

        // Helper function to make sure that an index into an aray is valid.

        fn array_inclusive_index_is_invalid(store: &Store, array_heap_pos: u32, idx: i64) -> bool {

            let array_len = store.heap_regions[array_heap_pos as usize].values.len();

            return idx < 0 || idx >= array_len as i64;

        }

        fn array_exclusive_index_is_invalid(store: &Store, array_heap_pos: u32, idx: i64) -> bool {

            let array_len = store.heap_regions[array_heap_pos as usize].values.len();

            return idx < 0 || idx > array_len as i64;

        }

        fn construct_array_error(prompt: &Prompt, modules: &[Module], heap: &Heap, expr_id: ExpressionId, heap_pos: u32, idx: i64) -> EvalError {

            let array_len = prompt.store.heap_regions[heap_pos as usize].values.len();

            return EvalError::new_error_at_expr(

                prompt, modules, heap, expr_id,

                format!("index {} is out of bounds: array length is {}", idx, array_len)

            )

        }

                                index.as_signed_integer() as i64

                                index.as_unsigned_integer() as i64

                            let (deallocate_heap_pos, value_to_push, subject_heap_pos) = match subject {

                                    if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {

                                        return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));

                                    }

                                    (None, Value::Ref(ValueId::Heap(subject_heap_pos, index as u32)), subject_heap_pos)

                                    if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {

                                        return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));

                                    }

                                    let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, index as u32));

                                    (Some(subject_heap_pos), self.store.clone_value(subject_indexed), subject_heap_pos)

                            // Evaluate indices

                            let from_index = cur_frame.expr_values.pop_back().unwrap();

                            let from_index = self.store.maybe_read_ref(&from_index);

                            let to_index = cur_frame.expr_values.pop_back().unwrap();

                            let to_index = self.store.maybe_read_ref(&to_index);

                            debug_assert!(from_index.is_integer() && to_index.is_integer());

                            let from_index = if from_index.is_signed_integer() {

                                from_index.as_signed_integer()

                            } else {

                                from_index.as_unsigned_integer() as i64

                            };

                            let to_index = if to_index.is_signed_integer() {

                                to_index.as_signed_integer()

                            } else {

                                to_index.as_unsigned_integer() as i64

                            };

                            // Dereference subject if needed

                            let subject = cur_frame.expr_values.pop_back().unwrap();

                            let deref_subject = self.store.maybe_read_ref(&subject);

                            // Slicing needs to produce a copy anyway (with the

                            // current evaluator implementation)

                            let array_heap_pos = deref_subject.as_array();

                            if array_inclusive_index_is_invalid(&self.store, array_heap_pos, from_index) {

                                return Err(construct_array_error(self, modules, heap, expr.from_index, array_heap_pos, from_index));

                            }

                            if array_exclusive_index_is_invalid(&self.store, array_heap_pos, to_index) {

                                return Err(construct_array_error(self, modules, heap, expr.to_index, array_heap_pos, to_index));

                            }

                            // Again: would love to push directly, but rust...

                            let new_heap_pos = self.store.alloc_heap();

                            debug_assert!(self.store.heap_regions[new_heap_pos as usize].values.is_empty());

                            if to_index > from_index {

                                let from_index = from_index as usize;

                                let to_index = to_index as usize;

                                let mut values = Vec::with_capacity(to_index - from_index);

                                for idx in from_index..to_index {

                                    let value = self.store.heap_regions[array_heap_pos as usize].values[idx].clone();

                                    values.push(self.store.clone_value(value));

                                }

                                self.store.heap_regions[new_heap_pos as usize].values = values;

                            } // else: empty range

                            cur_frame.expr_values.push_back(Value::Array(new_heap_pos));

                            // Dropping the original subject, because we don't

                            // want to drop something on the stack

                            self.store.drop_value(subject.get_heap_pos());

                                        _ => unreachable!("got concrete type {:?} for integer literal at expr {:?}", &expr.concrete_type, expr_id),

            assigning to anything. This should be completely valid, and this assertion should be \

pub(crate) mod error;

pub use error::EvalError;

        Value::Array(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_array()),

pub struct ErrorStatement {

impl ErrorStatement {

    pub(crate) fn from_source_at_span(statement_kind: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {

impl fmt::Display for ErrorStatement {

    pub(crate) statements: Vec<ErrorStatement>

        Self{ statements: vec!(ErrorStatement::from_source_at_pos(

        Self{ statements: vec!(ErrorStatement::from_source_at_pos(

        Self{ statements: vec!(ErrorStatement::from_source_at_span(

        Self{ statements: vec!(ErrorStatement::from_source_at_span(

        self.statements.push(ErrorStatement::from_source_at_pos(error_type, source, position, message));

        self.statements.push(ErrorStatement::from_source_at_span(error_type, source, span, message.to_string()));

use std::sync::Mutex;

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

/// A protocol description module

pub struct Module {

    pub(crate) source: InputSource,

    pub(crate) root_id: RootId,

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

}

    modules: Vec<Module>,

    pool: Mutex<StringPool>,

        let modules: Vec<Module> = parser.modules.into_iter()

            .map(|module| Module{

                source: module.source,

                root_id: module.root_id,

                name: module.name.map(|(_, name)| name)

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: parser.heap,

            pool: Mutex::new(parser.string_pool),

        });

        module_name: &[u8],

        let module_root = self.lookup_module_root(module_name);

        if module_root.is_none() {

            return Err(AddComponentError::NoSuchModule);

        }

        let module_root = module_root.unwrap();

        let root = &self.heap[module_root];

        let def = root.get_definition_ident(&self.heap, identifier);

        let def = &self.heap[def.unwrap()];

            let param = &self.heap[param];

            let param = &self.heap[param];

    pub(crate) fn new_component(&self, module_name: &[u8], identifier: &[u8], ports: &[PortId]) -> ComponentState {

        for (&x, y) in ports.iter().zip(self.component_polarities(module_name, identifier).unwrap()) {

        let module_root = self.lookup_module_root(module_name).unwrap();

        let root = &self.heap[module_root];

        let def = root.get_definition_ident(&self.heap, identifier).unwrap();

        ComponentState { prompt: Prompt::new(&self.heap, def, ValueGroup::new_stack(args)) }

    }

    fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {

        for module in self.modules.iter() {

            match &module.name {

                Some(name) => if name.as_bytes() == module_name {

                    return Some(module.root_id);

                },

                None => if module_name.is_empty() {

                    return Some(module.root_id);

                }

            }

        }

        return None;

            let result = self.prompt.step(&pd.heap, &pd.modules, &mut context);

                Err(err) => {

                    println!("Evaluation error:\n{}", err);

                    panic!("proper error handling when component fails");

                },

            let result = self.prompt.step(&pd.heap, &pd.modules, &mut context);

                Err(err) => {

                    println!("Evaluation error:\n{}", err);

                    panic!("proper error handling when component fails");

                },

                section.push(end_if.upcast());

                section.push(end_while.upcast());

                section.push(end_sync.upcast());

macro_rules! debug_log_enabled {

    () => { false };

}

    fn write_concrete_type(&self, concrete_type: &mut ConcreteType, discard_marked_types: bool) {

                    // When annotating the AST we keep the markers. When

                    // determining types for monomorphs we instead want to

                    // keep the type (not the markers)

                    if discard_marked_types {

                        idx = InferenceType::find_subtree_end_idx(&self.parts, idx + 1);

                        concrete_type.parts.push(CTP::Marker(*marker));

                    } else {

                        idx += 1;

                    }

// TODO: @Rename, this is used for a lot of type inferencing. It seems like

//  there is a different underlying architecture waiting to surface.

        if debug_log_enabled!() {

            debug_log!("Polymorphic variables:");

            for (idx, poly_var) in self.poly_vars.iter().enumerate() {

                let mut infer_type_parts = Vec::new();

                for concrete_part in &poly_var.parts {

                    infer_type_parts.push(InferenceTypePart::from(*concrete_part));

                }

                let infer_type = InferenceType::new(false, true, infer_type_parts);

                debug_log!(" - [{:03}] {:?}", idx, infer_type.display_name(&ctx.heap));

            }

        }

                expr_type.write_concrete_type(concrete_type, true);

                    expr_type.write_concrete_type(&mut concrete_type, true);

                    poly_type.write_concrete_type(&mut concrete_type, false);

                            _ => unreachable!("post-inference monomorph for non-struct, non-enum, non-union literal")

            self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 0)?;

                // Bit ugly, since we already have the definition, but we need

                // to work around rust borrowing rules...

        f.call_ok(Some(Value::UInt32(7)));

        f.call_ok(Some(Value::Bool(true)));

                f.call_ok(Some(expected_value));

                f.call_ok(Some(expected_value));

            auto array_check = lhs == rhs && total == total;

            return is_equal && !is_not_equal && has_correct_fields && array_check;

        f.call_ok(Some(Value::Bool(true)));