}

}

/// Default handling that has been received through a `get`. Will check if any

/// more messages are waiting, and if the corresponding port was blocked because

/// of full buffers (hence, will use the control layer to make sure the peer

/// will become unblocked).

pub(crate) fn default_handle_received_data_message(

    targeted_port: PortId, _port_instruction: PortInstruction, message: &mut DataMessage,

    inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup,

    comp_ctx: &mut CompCtx, sched_ctx: &SchedulerCtx, control: &mut ControlLayer

) -> Result<(), (PortInstruction, String)> {

    let port_handle = comp_ctx.get_port_handle(targeted_port);

    let port_index = comp_ctx.get_port_index(port_handle);

    debug_assert!(inbox_main[port_index].is_none()); // because we've just received from it

    // If we received any ports, add them to the port tracking and inbox struct.

    // Then notify the peers that they can continue sending to this port, but

    // now at a new address.

    for received_port in &mut message.ports {

        // Transfer messages to main/backup inbox

        let _new_inbox_index = inbox_main.len();

        if !received_port.messages.is_empty() {

            inbox_main.push(Some(received_port.messages.remove(0)));

        }

        // Create a new port locally

        let mut new_port_state = received_port.state;

        new_port_state.set(PortStateFlag::Received);

        let new_port_handle = comp_ctx.add_port(

            received_port.peer_comp, received_port.peer_port,

            received_port.kind, new_port_state

        );

        debug_assert_eq!(_new_inbox_index, comp_ctx.get_port_index(new_port_handle));

        comp_ctx.change_port_peer(sched_ctx, new_port_handle, Some(received_port.peer_comp));

        let new_port = comp_ctx.get_port(new_port_handle);

        // Replace all references to the port in the received message

        for message_location in received_port.locations.iter().copied() {

            let value = match message_location {

                ValueId::Heap(heap_pos, heap_index) => &mut message.content.regions[heap_pos as usize][heap_index as usize],

                ValueId::Stack(stack_index) => &mut message.content.values[stack_index as usize],

            };

            match value {

                Value::Input(_) => {

                    debug_assert_eq!(new_port.kind, PortKind::Getter);

                    *value = Value::Input(port_id_to_eval(new_port.self_id));

                },

    primitive port_receiver(in<in<u32>> rx) {

        sync auto a = get(rx);

    }

    composite constructor() {

        channel a -> b;

        new port_sender(a);

        new port_receiver(b);

    }

    ", "constructor", no_args());

}

#[test]

fn test_transfer_precreated_port_with_owned_peer_back_and_forth() {

}

#[test]

fn test_transfer_precreated_port_with_foreign_peer_back_and_forth() {

}

#[test]

fn test_transfer_precreated_port_with_owned_peer_and_communication() {

}

#[test]

fn test_transfer_precreated_port_with_foreign_peer_and_communication() {

}