_ => true,

        }

    }

}

// Note that we will have function definitions for builtin functions as well. In

// that case the span, the identifier span and the body are all invalid.

#[derive(Debug)]

pub struct ProcedureDefinition {

    pub this: ProcedureDefinitionId,

    pub defined_in: RootId,

        function.parameters = parameters;

        function.scope = scope_id;

        function.body = body_id;

        Ok(())

    }

    fn visit_component_definition(

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

    ) -> Result<(), ParseError> {

        // Consume component variant and name

        let (_component_text, _) = consume_any_ident(&module.source, iter)?;

        debug_assert!(_component_text == KW_COMPONENT);

                            },

                            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::FuncGet => Method::Get,

                                    ProcedureSource::FuncPut => Method::Put,

                                    ProcedureSource::FuncFires => Method::Fires,

                                    ProcedureSource::FuncCreate => Method::Create,

                                    ProcedureSource::FuncLength => Method::Length,

                                    ProcedureSource::FuncAssert => Method::Assert,

#[test]

fn test_correct_select_statement() {

    Tester::new_single_source_expect_ok(

        "guard variable decl",

        "

            channel<u32> unused -> input;

            u32 outer_value = 0;

            sync select {

                auto in_same_guard = get(input) -> {} // decl A1

                auto in_same_gaurd = get(input) -> {} // decl A2

        }

        "

    );

    Tester::new_single_source_expect_ok(

        "empty select",

    );

    Tester::new_single_source_expect_ok(

        "mixed uses", "

            channel unused_output -> input;

            u32 outer_value = 0;

            sync select {

                outer_value = get(input) -> outer_value = 0;

                auto new_value = get(input) -> {

                    outer_value = new_value;

}

#[test]

fn test_incorrect_select_statement() {

    Tester::new_single_source_expect_err(

        "outside sync",

    ).error(|e| { e

        .assert_num(1)

        .assert_occurs_at(0, "select")

        .assert_msg_has(0, "inside sync blocks");

    });

    Tester::new_single_source_expect_err(

        "variable in previous block",

            channel<u32> tx -> rx;

            u32 a = 0; // this one will be shadowed

            sync select { auto a = get(rx) -> {} }

        }"

    ).error(|e| { e

        .assert_num(2)

        .assert_occurs_at(0, "a = get").assert_msg_has(0, "variable name conflicts")

        .assert_occurs_at(1, "a = 0").assert_msg_has(1, "Previous variable");

    });

    Tester::new_single_source_expect_err(

        "put inside arm",

            channel<u32> a -> b;

            sync select { put(a) -> {} }

        }"

    ).error(|e| { e

        .assert_occurs_at(0, "put")

        .assert_msg_has(0, "may not occur");

        .assert_occurs_at(0, "nested;")

        .assert_msg_has(0, "could not find this label");

    });

    Tester::new_single_source_expect_err(

        "goto jumping outside sync",

            sync { goto exit; }

            exit: u32 v = 0;

        }"

    ).error(|e| { e

        .assert_num(3)

        .assert_occurs_at(0, "goto exit;").assert_msg_has(0, "not escape the surrounding sync")

        .assert_occurs_at(1, "exit: u32 v").assert_msg_has(1, "target of the goto")

        .assert_occurs_at(2, "sync {").assert_msg_has(2, "jump past this");

    });

    Tester::new_single_source_expect_err(

        "goto jumping to select case",

            sync select {

                hello: auto a = get(i) -> i += 1

            }

            goto hello;

        }"

    ).error(|e| { e

        .assert_msg_has(0, "expected '->'");

    });

    Tester::new_single_source_expect_err(

        "goto jumping into select case skipping variable",

            goto waza;

            sync select {

                auto a = get(i) -> {

                    waza: a += 1;

                }

            }

        .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")

        .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");

    });

    Tester::new_single_source_expect_err(

        "break outside of sync",

            outer: while (true) { //mark

                sync while(true) { break outer; }

            }

        }"

    ).error(|e| { e

        .assert_num(3)

use super::*;

#[test]

fn test_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

                auto value = get(request);

                put(response, value * 2);

            }

    }

}

#[test]

fn test_getting_from_component() {

    const CODE: &'static str ="

        while (cur < last) {

            sync {

                put(numbers, cur);

                cur += 1;

            }

        }

    }

}

#[test]

fn test_putting_to_component() {

    const CODE: &'static str = "

        while (cur < last) {

            sync {

                auto number = get(numbers);

                assert(number == cur);

                cur += 1;

            }

    }

}

#[test]

fn test_doing_nothing() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {}

            sync { auto res = get(input); assert(res); }

            index += 1;

        }

#[test]

fn test_doing_nothing() {

    // If this thing does not get into an infinite loop, (hence: the runtime

    // exits), then the test works

    const CODE: &'static str ="

        u32 index = 0;

        while (index < loops) {

            sync { index += 1; }

        }

    }

    ";

    });

}

#[test]

fn test_single_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

                put(sender, true);

            }

            index += 1;

        }

    }

        u32 index = 0;

        while (index < loops) {

            sync {

                auto result = get(receiver);

                assert(result);

            }

    });

}

#[test]

fn test_combined_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {

                put(output, true);

                auto value = get(input);

                assert(value);

                index += 1;

            }

        }

    }

        channel output_a -> input_a;

        channel output_b -> input_b;

        new put_then_get(output_a, input_b, num_loops);

        new put_then_get(output_b, input_a, num_loops);

    }

    ";

    })

}

#[test]

fn test_multi_put_and_get() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync {

                put(vals, 0b00000001);

                put(vals, 0b00000100);

                put(vals, 0b00010000);

                put(vals, 0b01000000);

            }

            index += 1;

        }

    }

        u32 loop_index = 0;

        while (loop_index < num_loops) {

            sync {

                u32 recv_index = 0;

                u8 expected = 1;

                while (recv_index < 4) {

use super::*;

#[test]

fn test_star_shaped_request() {

    const CODE: &'static str = "

        u32 index = 0;

        while (index < loops) {

            sync {

                auto req = get(input);

                put(output, req * 2);

            }

            index += 1;

        }

    }

        u32 loop_index = 0;

        auto num_edges = length(requests);

        while (loop_index < loops) {

            // print(\"starting loop\");

            sync {

            }

            // print(\"ending loop\");

            loop_index += 1;

        }

    }

        auto requests = {};

        auto responses = {};

        u32 edge_index = 0;

        while (edge_index < num_edges) {

            channel req_put -> req_get;

    });

}

#[test]

fn test_conga_line_request() {

    const CODE: &'static str = "

        u32 loop_index = 0;

        u32 initial_value = 1337;

        while (loop_index < num_loops) {

            sync {

                put(req, initial_value);

                auto result = get(resp);

                assert(result == initial_value + num_nodes * 2);

            }

            loop_index += 1;

        }

    }

        in<u32> req_in, out<u32> req_forward,

        in<u32> resp_in, out<u32> resp_forward,

        u32 num_loops

    ) {

        u32 loop_index = 0;

        while (loop_index < num_loops) {

                put(resp_forward, resp + 1);

            }

            loop_index += 1;

        }

    }

        u32 loop_index = 0;

        while (loop_index < num_loops) {

            sync {

                auto req = get(req_in);

                put(resp_out, req);

            }

            loop_index += 1;

        }

    }

        channel initial_req -> req_in;

        channel resp_out -> final_resp;

        new start(initial_req, final_resp, num_nodes, num_loops);

        in<u32> last_req_in = req_in;

        out<u32> last_resp_out = resp_out;

#[test]

fn test_maybe_do_nothing() {

    // Three variants in which the behaviour in which nothing is performed is

    // somehow not allowed. Note that we "check" by seeing if the test finishes.

    // Only the branches in which ports fire increment the loop index

    const CODE: &'static str = "

        u32 index = 0;

        while (index < num_loops) {

            sync { put(output, true); }

            index += 1;

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync {

                fork { put(output, true); index += 1; }

                or   {}

            }

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync { auto res = get(input); assert(res); }

            index += 1;

        }

    }

        u32 index = 0;

        while (index < num_loops) {

            sync fork { auto res = get(input); assert(res); index += 1; } or {}

        }

    }

    ";

#[test]

fn test_local_sync_failure() {

    // If the component exits cleanly, then the runtime exits cleanly, and the

    // test will finish

    const CODE: &'static str = "

        u32[] only_allows_index_0 = { 1 };

        while (true) sync { // note the infinite loop

            auto value = only_allows_index_0[1];

        }

    }

        u32[] only_allows_index_0 = { 1 };

        auto never_gonna_get = only_allows_index_0[1];

        while (true) sync {}

    }

    ";

            .expect("create component");

    })

}

const SHARED_SYNC_CODE: &'static str = "

enum Location { BeforeSync, AfterPut, AfterGet, AfterSync, Never }

    u32[] failure_array = {};

    while (true) {

        if (loc == Location::BeforeSync) failure_array[0];

        sync {

            put(output, true);

            if (loc == Location::AfterPut) failure_array[0];

            if (loc == Location::AfterGet) failure_array[0];

        }

        if (loc == Location::AfterSync) failure_array[0];

    }

}

    channel output_a -> input_a;

    channel output_b -> input_b;

    new failing_at_location(input_b, output_a, loc);

    new failing_at_location(input_a, output_b, Location::Never);

}

    channel output_a -> input_a;

    channel output_b -> input_b;

    new failing_at_location(input_b, output_a, Location::Never);

    new failing_at_location(input_a, output_b, loc);

}

    channel output_first -> input_old;

    channel output_cur -> input_new;

    u32 ring_index = 0;

    while (ring_index < ring_size) {

        auto cur_loc = Location::Never;

        default_handle_sync_decision(sched_ctx, exec_state, comp_ctx, decision, consensus);

    }

    // Iterating over ports by index to work around borrowing rules

    for port_index in 0..comp_ctx.num_ports() {

        let port = comp_ctx.get_port_by_index_mut(port_index);

        if port.state.is_closed() || port.state.is_set(PortStateFlag::Transmitted) || port.close_at_sync_end {

            // Already closed, or in the process of being closed

            continue;

        }

        // Mark as closed

use super::*;

#[test]

fn test_unconnected_component_error() {

    compile_and_create_component("

        u8[] array = { 5 };

        auto value = array[1];

    }", "interact_with_noone", no_args());

}

#[test]

fn test_connected_uncommunicating_component_error() {

    compile_and_create_component("

        u8[] array = { 1337 };

        auto value = array[1337];

    }

        sync auto a = get(never_providing);

    }

        // Test one way

        // channel a -> b;

        // new sitting_idly_waiting(b);

        // new crashing_and_burning(a);

        // And the other way around

    }", "constructor", no_args())

}

#[test]

fn test_connected_communicating_component_error() {

    compile_and_create_component("

        u8[] array = {};

        sync {

            put(tx, 0);

            array[0] = 5;

        }

    }

        sync auto a = get(rx);

    }

        channel a -> b;

        new send_and_fail(a);

        new receive_once(b);

        channel c -> d;

        new receive_once(d);

    ", "constructor", no_args())

}

#[test]

fn test_failing_after_successful_sync() {

    compile_and_create_component("

        {

            channel a -> b;

            new put_and_fail(a);

            new get_and_exit(b);

        }

        {

// stuff with the actual components

#[test]

fn test_stdlib_file() {

    compile_and_create_component("

    import std.internet as inet;

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        sync put(tx, inet::TcpConnection{

            tx: cmd_tx,

            rx: data_rx,

        });

    }

        auto to_send = {};

        auto shutdown = false;

        while (!shutdown) {

            auto keep_going = true;

            sync {

                while (keep_going) {

                    if (let inet::Cmd::Send(data) = cmd) {

                        to_send = data;

                        put(tx, to_send);

                    } else if (let inet::Cmd::Finish = cmd) {

                        keep_going = false;

                    } else if (let inet::Cmd::Shutdown = cmd) {

                        keep_going = false;

                        shutdown = true;

                    }

                }

            }

        }

    }

        sync put(conn.tx, inet::Cmd::Send({1, 3, 3, 7}));

        sync {

            put(conn.tx, inet::Cmd::Receive);

            auto val = get(conn.rx);

            while (val[0] != 1 || val[1] != 3 || val[2] != 3 || val[3] != 7) {}

            put(conn.tx, inet::Cmd::Finish);

        }

        sync put(conn.tx, inet::Cmd::Shutdown);

    }

        channel conn_tx -> conn_rx;

        new fake_listener_once(conn_tx);

        // Same crap as before:

        channel cmd_tx -> unused_cmd_rx;

        channel unused_data_tx -> data_rx;

use super::*;

#[test]

fn test_component_communication() {

    let pd = ProtocolDescription::parse(b"

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

            u32 inside_index = 0;

            sync while (inside_index < inside_loops) {

                put(o, inside_index);

                inside_index += 1;

            }

            outside_index += 1;

        }

    }

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

            u32 inside_index = 0;

            sync while (inside_index < inside_loops) {

                auto val = get(i);

                while (val != inside_index) {} // infinite loop if incorrect value is received

                inside_index += 1;

            }

            outside_index += 1;

        }

    }

        channel o_orom -> i_orom;

        channel o_mrom -> i_mrom;

        channel o_ormm -> i_ormm;

        channel o_mrmm -> i_mrmm;

        // one round, one message per round

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

}

#[test]

fn test_send_to_self() {

    compile_and_create_component("

        channel a -> b;

        sync {

            put(a, 1);

            auto v = get(b);

            while (v != 1) {}

        }

    ", "insane_in_the_membrane", no_args());

}

#[test]

fn test_intermediate_messenger() {

    let pd = ProtocolDescription::parse(b"

        auto index = 0;

        while (index < num) {

            sync { auto v = get(rx); }

            index += 1;

        }

    }

        auto index = 0;

        while (index < num) {

            sync { put(tx, get(rx)); }

            index += 1;

        }

    }

        auto index = 0;

        while (index < num) {

            sync put(tx, 1337);

            index += 1;

        }

    }

        auto num = 0;

        channel<T> tx_a -> rx_a;

        channel tx_b -> rx_b;

        new sender(tx_a, 3);

        new middleman(rx_a, tx_b, 3);

        new receiver(rx_b, 3);

    }

        new constructor_template<u16>();

        new constructor_template<u32>();

        new constructor_template<u64>();