Result location semantics provide footgun for recursive data structures

[ikskuh]

When writing and reading a structure at the same time, result semantics will destroy information:

const std = @import("std");

const Recursive = union(enum) {
    terminal: void,
    recurse: struct {
        left: *Recursive,
        right: *Recursive,
    },
};

fn moveToHeap(value: anytype) !*@TypeOf(value) {
    const T = @TypeOf(value);
    std.debug.assert(@typeInfo(T) != .Pointer);
    const ptr = try std.heap.page_allocator.create(T);
    ptr.* = value;
    return ptr;
}

pub fn main() !void {
    var root = Recursive {
        .terminal = {},
    };

    root = Recursive { // temporary
        .recurse = .{
            .left = try moveToHeap(root), // this will clone a value with the wrong value
            .right = try moveToHeap(Recursive {
                .terminal = {}
            }),
        },
    };

    std.debug.print("{}\n", .{
        root
    });

    var i: usize = 0;
    var ptr = &root;

    while(i < 10) : (i += 1) {
        std.debug.print("[{d}] => 0x{X}\n", .{
            i,
            @ptrToInt(ptr),
        });
        ptr = ptr.recurse.left;
    }
}

This example shows that the value copied by moveToHeap(root) is corrupted and is a copy of the temporary constructed, but has a different address.

https://zig.godbolt.org/z/571T4W

A simple workaround is this:

    var temp_root = Recursive { // temporary
        .recurse = .{
            .left = try moveToHeap(root), // this will clone a value with the wrong contents
            .right = try moveToHeap(Recursive {
                .terminal = {}
            }),
        },
    };
    root = temp_root;

[rohlem]

See also: #3696 for general discussion of overwriting a composite type, and #3234 for specifically the case of overwriting a union.

I don't know whether there was some big discussion yet, but from comments up to now I believe manually creating the temporary, and/or initializing some fields after initial construction, is the "intended solution" (so these self-dependencies will hopefully be caught by a compile error at some point).
(This will probably also interact with the aliasing strategy for function arguments; see #1108 .)