};

}

#[derive(Debug, Clone)]

pub(crate) enum ExprInstruction {

    EvalExpr(ExpressionId),

    PushValToFront,

}

#[derive(Debug, Clone)]

pub(crate) struct Frame {

    pub(crate) definition: ProcedureDefinitionId,

    pub(crate) monomorph_index: usize,

    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

    pub(crate) max_stack_size: u32,

}

impl Frame {

    /// Creates a new execution frame. Does not modify the stack in any way.

        let definition = &heap[definition_id];

        let outer_scope_id = definition.scope;

        let first_statement_id = definition.body;

        // Another not-so-pretty thing that has to be replaced somewhere in the

        // future...

        fn determine_max_stack_size(heap: &Heap, scope_id: ScopeId, max_size: &mut u32) {

            let scope = &heap[scope_id];

            // Check current block

            let cur_size = scope.next_unique_id_in_scope as u32;

            if cur_size > *max_size { *max_size = cur_size; }

            // And child blocks

            for child_scope in &scope.nested {

                determine_max_stack_size(heap, *child_scope, max_size);

            }

        }

        let mut max_stack_size = 0;

        determine_max_stack_size(heap, outer_scope_id, &mut max_stack_size);

        Frame{

            definition: definition_id,

            monomorph_index: monomorph_index as usize,

            position: first_statement_id.upcast(),

            expr_stack: VecDeque::with_capacity(128),

            expr_values: VecDeque::with_capacity(128),

            max_stack_size,

        }

    }

    /// Prepares a single expression for execution. This involves walking the

    /// expression tree and putting them in the `expr_stack` such that

    /// continuously popping from its back will evaluate the expression. The

    /// results of each expression will be stored by pushing onto `expr_values`.

        {

            let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectWait, &mut self.expression_buffer, Vec::new());

            let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, select_variable_id, select_variable_type, runtime_call_expr_id.upcast());

            transformed_stmts.push(variable_stmt_id.upcast().upcast());

        }

        call_id_section.forget();

        expr_id_section.forget();

        // Now we transform each of the select block case's guard and code into

        // a chained if-else statement.

        if total_num_cases > 0 {

            let (if_stmt_id, end_if_stmt_id, scope_id) = transform_select_case_code(ctx, self.current_procedure_id, id, 0, select_variable_id, select_variable_type);

            link_existing_child_to_new_parent_scope(ctx, &mut self.scope_buffer, outer_scope_id, scope_id, relative_pos);

            let first_end_if_stmt = &mut ctx.heap[end_if_stmt_id];

            first_end_if_stmt.next = outer_end_block_id.upcast();

            let mut last_if_stmt_id = if_stmt_id;

            let mut last_end_if_stmt_id = end_if_stmt_id;

            let mut last_parent_scope_id = outer_scope_id;

            let mut last_relative_pos = transformed_stmts.len() as i32 + 1;

            transformed_stmts.push(last_if_stmt_id.upcast());

            // specific locations.

            let is_valid_binding = match self.expr_parent {

                ExpressionParent::Expression(expr_id, idx) => {

                    match &ctx.heap[expr_id] {

                        Expression::Binding(_binding_expr) => {

                            // Nested binding is disallowed, and because of

                            // the check above we know we're directly at the

                            // LHS of the binding expression

                            debug_assert_eq!(_binding_expr.this, self.in_binding_expr);

                            debug_assert_eq!(idx, 0);

                            true

                        }

                            // Only struct, unions, tuples and arrays can

                            // have subexpressions, so we're always fine

                            dbg_code!({

                                    Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},

                                    _ => unreachable!(),

                                }

                            });

                            true

                        },

                        _ => false,

                    }

                },

                _ => {

                    false

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

// Defined Types

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

/// Struct wrapping around a potentially polymorphic type. If the type does not

/// have any polymorphic arguments then it will not have any monomorphs and

/// `is_polymorph` will be set to `false`. A type with polymorphic arguments

/// only has `is_polymorph` set to `true` if the polymorphic arguments actually

/// appear in the types associated types (function return argument, struct

/// field, enum variant, etc.). Otherwise the polymorphic argument is just a

/// marker and does not influence the bytesize of the type.

pub struct DefinedType {

    pub(crate) ast_root: RootId,

    pub(crate) ast_definition: DefinitionId,

    pub(crate) definition: DefinedTypeVariant,

    pub(crate) poly_vars: Vec<PolymorphicVariable>,

    pub(crate) is_polymorph: bool,

}

pub enum DefinedTypeVariant {

    Enum(EnumType),

    Union(UnionType),

    Struct(StructType),

    /// Checks if the specified type needs to be resolved (i.e. we need to push

    /// a breadcrumb), is already resolved (i.e. we can continue with the next

    /// member of the currently considered type) or is in the process of being

    /// resolved (i.e. we're in a type loop). Because of borrowing rules we

    /// don't do any modifications of internal types here. Hence: if we

    /// return `PushBreadcrumb` then call `handle_new_breadcrumb_for_type_loops`

    /// to take care of storing the appropriate types.

    fn check_member_for_type_loops(

        breadcrumbs: &[TypeLoopBreadcrumb], definition_map: &DefinitionMap, mono_type_map: &MonoTypeMap,

        mono_key: &mut MonoSearchKey, concrete_type: &ConcreteType

    ) -> TypeLoopResult {

        // Depending on the type, lookup if the type has already been visited

        // (i.e. either already has its memory layed out, or is part of a type

        // loop because we've already visited the type)

        debug_assert!(!concrete_type.parts.is_empty());

        let definition_id = if let ConcreteTypePart::Instance(definition_id, _) = concrete_type.parts[0] {

            definition_id

        } else {

            DefinitionId::new_invalid()

        };

        Self::set_search_key_to_type(mono_key, definition_map, &concrete_type.parts);

        if let Some(type_id) = mono_type_map.get(mono_key).copied() {

            // Try to wake ourselves up (needed because someone might be trying

            // the exact same atomic compare-and-swap at this point in time)

            let should_wake_up_again = connector.public.sleeping

                .compare_exchange(true, false, Ordering::SeqCst, Ordering::Acquire)

                .is_ok();

            if should_wake_up_again {

                self.runtime.push_work(connector_key)

            }

        }

    }

        // println!("DEBUG [thrd:{:02} conn:  ]: {}", self.scheduler_id, message);

    }

        // println!("DEBUG [thrd:{:02} conn:{:02}]: {}", self.scheduler_id, conn.index, message);

    }

}

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

// ComponentCtx

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

enum ComponentStateChange {

    CreatedComponent(ConnectorPDL, Vec<PortIdLocal>),

    CreatedPort(Port),

    ChangedPort(ComponentPortChange),

    /// Creates a new channel that is fully owned by the component associated

    /// with this context.

    pub(crate) fn create_channel(&mut self) -> Channel {

        let putter_id = PortId(self.take_port_id());

        let getter_id = PortId(self.take_port_id());

        self.ports.push(Port{

            self_id: putter_id,

            peer_port_id: getter_id,

            kind: PortKind::Putter,

            state: PortState::Open,

            peer_comp_id: self.id,

        });

        self.ports.push(Port{

            self_id: getter_id,

            peer_port_id: putter_id,

            kind: PortKind::Getter,

            state: PortState::Open,

            peer_comp_id: self.id,

        });

        return Channel{ putter_id, getter_id };

    }

    /// Adds a new port. Make sure to call `add_peer` afterwards.

    pub(crate) fn add_port(&mut self, peer_comp_id: CompId, peer_port_id: PortId, kind: PortKind, state: PortState) -> LocalPortHandle {

        let self_id = PortId(self.take_port_id());

        self.ports.push(Port{

            self_id, peer_comp_id, peer_port_id, kind, state,

            #[cfg(debug_assertions)] associated_with_peer: false,

        });

        return LocalPortHandle(self_id);

    }

    /// Removes a port. Make sure you called `remove_peer` first.

    pub(crate) fn remove_port(&mut self, port_handle: LocalPortHandle) -> Port {

        let port_index = self.must_get_port_index(port_handle);

        let port = self.ports.remove(port_index);

        return port;

    }

    /// Adds a new peer. This must be called for every port, no matter the

    /// component the channel is connected to. If a `CompHandle` is supplied,

    /// then it will be used to add the peer. Otherwise it will be retrieved

    /// from the runtime using its ID.

    pub(crate) fn add_peer(&mut self, port_handle: LocalPortHandle, sched_ctx: &SchedulerCtx, peer_comp_id: CompId, handle: Option<&CompHandle>) {

        let self_id = self.id;

        let port = self.get_port_mut(port_handle);

        debug_assert_eq!(port.peer_comp_id, peer_comp_id);

        if !Self::requires_peer_reference(port, self_id, false) {

            return;

        }

        dbg_code!(port.associated_with_peer = true);

        match self.get_peer_index_by_id(peer_comp_id) {

            Some(peer_index) => {

                let peer = &mut self.peers[peer_index];

                peer.num_associated_ports += 1;

            },

            None => {

                let handle = match handle {

        }

    }

    /// Removes a peer associated with a port.

    pub(crate) fn remove_peer(&mut self, sched_ctx: &SchedulerCtx, port_handle: LocalPortHandle, peer_id: CompId, also_remove_if_closed: bool) {

        let self_id = self.id;

        let port = self.get_port_mut(port_handle);

        debug_assert_eq!(port.peer_comp_id, peer_id);

        if !Self::requires_peer_reference(port, self_id, also_remove_if_closed) {

            return;

        }

        dbg_code!(port.associated_with_peer = false);

        let peer_index = self.get_peer_index_by_id(peer_id).unwrap();

        let peer = &mut self.peers[peer_index];

        peer.num_associated_ports -= 1;

        if peer.num_associated_ports == 0 {

            let mut peer = self.peers.remove(peer_index);

            if let Some(key) = peer.handle.decrement_users() {

                debug_assert_ne!(key.downgrade(), self.id); // should be upheld by the code that shuts down a component

                sched_ctx.runtime.destroy_component(key);

            }

        }

    }

        if try_wake_up {

            wake_up_if_sleeping(sched_ctx, self.id, self);

        }

    }

    fn increment_users(&self) {

        let old_count = self.num_handles.fetch_add(1, Ordering::AcqRel);

        debug_assert!(old_count > 0); // because we should never be able to retrieve a handle when the component is (being) destroyed

    }

    /// Returns the `CompKey` to the component if it should be destroyed

    pub(crate) fn decrement_users(&mut self) -> Option<CompKey> {

        let old_count = self.num_handles.fetch_sub(1, Ordering::AcqRel);

        let new_count = old_count - 1;

        dbg_code!(self.decremented = true);

        if new_count == 0 {

            return Some(unsafe{ self.id.upgrade() });

        }

        return None;

    }

}

impl Clone for CompHandle {

    fn clone(&self) -> Self {

        self.increment_users();

        return CompHandle{

            target: self.target,

            id: self.id,

            #[cfg(debug_assertions)] decremented: false,

        };

    }

}

impl std::ops::Deref for CompHandle {

    type Target = CompPublic;

    fn deref(&self) -> &Self::Target {

        return unsafe{ &*self.target };

    }

}

impl Drop for CompHandle {

    fn drop(&mut self) {

    }

}

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

// Runtime

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

pub struct Runtime {

    pub(crate) inner: Arc<RuntimeInner>,

    threads: Vec<std::thread::JoinHandle<()>>,

}

            runtime,

            id,

            comp: 0,

            logging_enabled,

        }

    }

    pub(crate) fn log(&self, text: &str) {

        if self.logging_enabled {

            println!("[s:{:02}, c:{:03}] {}", self.id, self.comp, text);

        }

    }

}

impl Scheduler {

    // public interface to thread

    pub fn new(runtime: Arc<RuntimeInner>, scheduler_id: u32, debug_logging: bool) -> Self {

        return Scheduler{ runtime, scheduler_id, debug_logging }

    }

    pub fn run(&mut self) {

        let mut scheduler_ctx = SchedulerCtx::new(&*self.runtime, self.scheduler_id, self.debug_logging);

impl ComponentReservation {

    fn new(index: u32) -> Self {

        return Self{

            index,

            #[cfg(debug_assertions)] submitted: false,

        }

    }

}

impl Drop for ComponentReservation {

    fn drop(&mut self) {

    }

}

impl<T: Sized> ComponentStore<T> {

    pub fn new(initial_size: usize) -> Self {

        Self::assert_valid_size(initial_size);

        // Fill initial freelist and preallocate data array

        let mut initial_freelist = Vec::with_capacity(initial_size);

        for idx in 0..initial_size {

            initial_freelist.push(idx as u32)

        }

            // Load indices and check for reallocation condition

            let current_size = shared_lock.size;

            let mut read_index = self.read_head.load(Ordering::Relaxed);

            let limit_index = self.limit_head.load(Ordering::Acquire);

            if read_index == limit_index {

                shared_lock = self.reallocate(current_size, shared_lock);

                continue 'attempt_read;

            }

            loop {

                let preemptive_read = shared_lock.freelist[read_index & shared_lock.index_mask];

                    read_index, (read_index + 1) & shared_lock.compare_mask,

                    Ordering::AcqRel, Ordering::Acquire

                ) {

                    // We need to try again

                    continue 'attempt_read;

                }

                // If here then we performed the read

                return (shared_lock, preemptive_read);

            }

        }

    }

    #[inline]

    fn initialize_at_index(read_lock: InnerShared<T>, index: u32, value: T) {

        let mut target_ptr = read_lock.data[index as usize];