Comptime function calls being memoised or not depending on return type

[ghost]

(N.B.: Some details may be incorrect. I can't compile atm, so i can't check.)

The following code prints 1:

const std = @import("std");

usingnamespace blk: {
    comptime var counter: u64 = 0;

    break :blk struct {
        pub fn getValue() type {
            counter += 1;

            return struct { value: u64 = counter };
        }
    };
};

pub fn main() !void {
    _ = getValue();
    _ = getValue();

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

This is because the call to getValue at comptime is memoised.

The following code prints 3:

const std = @import("std");

fn ComptimeOnly(comptime T: type) type {
    return struct { value: T, _: var = undefined, };
}

usingnamespace blk: {
    comptime var counter: u64 = 0;

    break :blk struct {
        pub fn getValue() ComptimeOnly(u64) {
            counter += 1;

            return .{ .value = counter };
        }
    };
};

pub fn main() !void {
    _ = getValue();
    _ = getValue();

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

This indicates that getValue is not being memoised.

Not sure if this is a bug or overzealous special casing, but either way it's not right. Either both getValue's should be memoised, or neither should. (Personally I think comptime closures are a mistake -- see #5718.)