// TODO: @Monomorph These fields cannot be trusted because the last time it

    //  was typed it may refer to a different monomorph.

                            // Note: although not pretty, the assignment operator takes ownership

                            // of the right-hand side value when possible. So we do not drop the

                            // rhs's optionally owned heap data.

                            let rhs = self.store.read_take_ownership(rhs);

                            let (deallocate_heap_pos, value_to_push) = match subject {

                                    // Our expression stack value is a reference to something that

                                    // exists in the normal stack/heap. We don't want to deallocate

                                    // this thing. Rather we want to return a reference to it.

                                    let subject = self.store.read_ref(value_ref);

                                    let subject_heap_pos = subject.as_array();

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

                                },

                                _ => {

                                    // Our value lives on the expression stack, hence we need to

                                    // clone whatever we're referring to. Then drop the subject.

                                    let subject_heap_pos = subject.as_array();

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

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

                            cur_frame.expr_values.push_back(value_to_push);

                            self.store.drop_value(deallocate_heap_pos);

                            let field_idx = expr.field.as_symbolic().field_idx as u32;

                            // Note: same as above: clone if value lives on expr stack, simply

                            // refer to it if it already lives on the stack/heap.

                            let (deallocate_heap_pos, value_to_push) = match subject {

                                Value::Ref(value_ref) => {

                                    let subject = self.store.read_ref(value_ref);

                                    let subject_heap_pos = subject.as_struct();

                                    (None, Value::Ref(ValueId::Heap(subject_heap_pos, field_idx)))

                                },

                                _ => {

                                    let subject_heap_pos = subject.as_struct();

                                    let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, field_idx));

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

                                },

                            cur_frame.expr_values.push_back(value_to_push);

                            self.store.drop_value(deallocate_heap_pos);

                // We just returned to the previous frame, which might be in

                // the middle of evaluating expressions for a particular

                // statement. So we don't want to enter the code below.

        assert!(

            cur_frame.expr_values.is_empty(),

            "This is a debugging assertion that will fail if you perform expressions without \

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

            replaced by something that clears the expression values if needed, but I'll keep this \

            in for now for debugging purposes."

        );

    pub(crate) fn clone_value(&mut self, value: Value) -> Value {

    // let rhs = store.maybe_read_ref(&rhs).clone(); // we don't own this thing, so don't drop it

        let lhs_heap_pos = lhs_heap_pos as usize;

        let rhs_heap_pos = rhs_heap_pos as usize;

        let lhs_len = store.heap_regions[lhs_heap_pos].values.len();

        let rhs_len = store.heap_regions[rhs_heap_pos].values.len();

        concatenated.reserve(lhs_len + rhs_len);

        for idx in 0..lhs_len {

            concatenated.push(store.clone_value(store.heap_regions[lhs_heap_pos].values[idx].clone()));

        }

        for idx in 0..rhs_len {

            concatenated.push(store.clone_value(store.heap_regions[rhs_heap_pos].values[idx].clone()));

        }

const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];

        // TODO: @Monomorph, this is a temporary hack, see other comments

        let expr = &mut ctx.heap[id];

        if let Field::Symbolic(field) = &mut expr.field {

            field.definition = None;

            field.field_idx = 0;

        }

        // TODO: @Monomorph, this is completely wrong. It seemed okay, but it

        //  isn't. Each monomorph might result in completely different internal

        //  types.

        // Assignment does not return anything (it operates like a statement)

        let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;

        // Apply forced constraint to LHS value

        let progress_forced = match expr.operation {

                self.apply_forced_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,

                self.apply_forced_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,

        let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(

            ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0

        debug_assert!(if progress_forced { progress_arg2 } else { true });

        debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.expr_types.get(&arg1_expr_id).unwrap().display_name(&ctx.heap));

        debug_log!("   - Expr type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_forced || progress_arg1 { self.queue_expr(arg1_expr_id); }

        debug_log!("Variable expr '{}': {}", ctx.heap[var_id].identifier.value.as_str(), upcast_id.index);

use super::*;

#[test]

fn test_concatenate_operator() {

    Tester::new_single_source_expect_ok(

        "concatenate and check values",

        "

        // Too see if we accept the polymorphic arg

        func check_pair<T>(T[] arr, u32 idx) -> bool {

            return arr[idx] == arr[idx + 1];

        }

        // Too see if we can check fields of polymorphs

        func check_values<T>(T[] arr, u32 idx, u32 x, u32 y) -> bool {

            auto value = arr[idx];

            return value.x == x && value.y == y;

        }

        struct Point2D {

            u32 x,

            u32 y,

        }

        // Could do this inline, but we're attempt to stress the system a bit

        func create_point(u32 x, u32 y) -> Point2D {

            return Point2D{ x: x, y: y };

        }

        // Again, more stressing: returning a heap-allocated thing

        func create_array() -> Point2D[] {

            return {

                create_point(1, 2),

                create_point(1, 2),

                create_point(3, 4),

                create_point(3, 4)

            };

        }

        // The silly checkamajig

        func foo() -> bool {

            auto lhs = create_array();

            auto rhs = create_array();

            auto total = lhs @ rhs;

            auto is_equal =

                check_pair(total, 0) &&

                check_pair(total, 2) &&

                check_pair(total, 4) &&

                check_pair(total, 6);

            auto is_not_equal =

                !check_pair(total, 0) ||

                !check_pair(total, 2) ||

                !check_pair(total, 4) ||

                !check_pair(total, 6);

            auto has_correct_fields =

                check_values(total, 3, 3, 4) &&

                check_values(total, 4, 1, 2);

            return is_equal && !is_not_equal && has_correct_fields;

        }

        "

    ).for_function("foo", |f| {

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

    });

}

#[test]

fn test_struct_fields() {

    Tester::new_single_source_expect_ok("struct field access",

"

struct Nester<T> {

    T v,

}

func make<T>(T inner) -> Nester<T> {

    return Nester{ v: inner };

}

func modify<T>(Nester<T> outer, T inner) -> Nester<T> {

    outer.v = inner;

    return outer;

}

func foo() -> bool {

    // Single depth modification

    auto original1 = make<u32>(5);

    auto modified1 = modify(original1, 2);

    auto success1 = original1.v == 5 && modified1.v == 2;

    // Multiple levels of modification

    auto original2 = make(make(make(make(true))));

    auto modified2 = modify(original2.v, make(make(false))); // strip one Nester level

    auto success2 = original2.v.v.v.v == true && modified2.v.v.v == false;

    return success1 && success2;

}

").for_function("foo", |f| {

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

    });

}

mod eval_silly;

pub(crate) use utils::{Tester}; // the testing harness

pub(crate) use crate::protocol::eval::value::*; // to test functions

        let lhs = self.ctx.heap[self.assignment.left].as_variable();

            &lhs.concrete_type