Function function_stack_ordering

tangle/src/ir.rs:676–743

()

    #[test]
    pub fn function_stack_ordering() {
        let mut ir = IR::new();
        let mut f = Node::function::<1, 1>(&mut ir);
        let input = f.add_argument(&mut ir);
        let output = f.add_return(&mut ir);
        // We create a stack slot
        let mut ss1 = f.add_stack_slot(&mut ir);
        let initial_ss = ss1;

        // ...and push, which should resolve to a use of ss1
        let mut push = Node::simple(Operation::StoreStack);
        ss1 = f.add_body(push, &mut ir, |i, r| {
            i.connect_input(0, ss1, r);
            i.connect_input(1, input, r);
            i.sinks()[0]
        }).1;

        let mut pop = Node::simple(Operation::LoadStack);
        let ss_val_0 = f.add_body(pop, &mut ir, |i, r| {
            i.connect_input(0, ss1, r);
            i.sinks()[0]
        }).1;

        // then add to it via ss1
        let mut two = Node::constant(2);
        let mut add = Node::simple(Operation::Add);
        let mut two_const = f.add_body(two, &mut ir, |two, r| {
            two.sinks()[0]
        }).1;
        let added_val = f.add_body(add, &mut ir, |add, r| {
            println!("add closure {}", r.ports[ss1].storage);
            add.connect_input(0, ss_val_0, r);
            add.connect_input(1, two_const, r);
            add.sinks()[0]
        }).1;

        // and store it again
        let mut push = Node::simple(Operation::StoreStack);
        f.add_body(push, &mut ir, |i, r| {
            i.connect_input(0, ss1, r);
            i.connect_input(1, added_val, r);
            ss1 = i.sinks()[0];
        });

        // make a use of the *initial* stack value from before the load
        let mut pop = Node::simple(Operation::LoadStack);
        let ss_val_1 = f.add_body(pop, &mut ir, |i, r| {
            i.connect_input(0, initial_ss, r);
            i.sinks()[0]
        }).1;

        let mut three = Node::constant(3);
        let mut add = Node::simple(Operation::Add);
        let mut three_const = f.add_body(three, &mut ir, |three, r| {
            three.sinks()[0]
        }).1;
        f.add_body(add, &mut ir, |add, r| {
            add.connect_input(0, ss_val_1, r);