wrong branching of if(optional) in anonymous list literal

[jakwings]

version 5e37fc0 (master)

const std = @import("std");

fn testFmt(expected: var, actual: var) !void {
    var buf1: [512]u8 = undefined;
    var buf2: [512]u8 = undefined;
    const result1 = try std.fmt.bufPrint(buf1[0..], "{}", .{expected});
    const result2 = try std.fmt.bufPrint(buf2[0..], "{}", .{actual.@"0"});
    if (std.mem.eql(u8, result1, result2)) return;

    std.debug.warn("\n====== expected this output: =========\n", .{});
    std.debug.warn("{}", .{result1});
    std.debug.warn("\n======== instead found this: =========\n", .{});
    std.debug.warn("{}", .{result2});
    std.debug.warn("\n======================================\n", .{});
    return error.TestFailure;
}
fn foo(bar: var) void {}

test "wrong branching of if(optional) in anonymous list literal" {
    const T = usize;
    var x: ?T = null;
    const a: T = 1;
    const b: T = 2;
    const c: T = 3;

    // all pass
    _ = if (x != null) x.? else b;
    _ = if (x) |xx| xx else b;
    _ = if (x) |_| x.? else b;
    _ = if (x) |_| unreachable else b;

    // all pass
    std.testing.expectEqual(b, if (x != null) x.? else b);
    std.testing.expectEqual(b, if (x != null) a else b);
    std.testing.expectEqual(b, if (x) |xx| xx else b);
    std.testing.expectEqual(b, if (x) |xx| a else b);
    std.testing.expectEqual(b, if (x) |_| x.? else b);
    std.testing.expectEqual(b, if (x) |_| a else b);
    std.testing.expectEqual(b, if (x) |_| unreachable else b);

    // all pass
    std.testing.expectEqual([_]T{b}, [_]T{if (x != null) x.? else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x != null) a else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x) |xx| xx else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x) |xx| a else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x) |_| x.? else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x) |_| a else b});
    std.testing.expectEqual([_]T{b}, [_]T{if (x) |_| unreachable else b});

    // useful hint? error: cannot store runtime value in compile time variable
    //foo(.{x orelse b});

    try testFmt(b, .{if (x != null) x.? else b});
    try testFmt(b, .{if (x != null) a else b}); // failure
    try testFmt(b, .{if (x) |xx| xx else b});
    try testFmt(b, .{if (x) |xx| a else b}); // failure
    try testFmt(b, .{if (x) |_| x.? else b});
    try testFmt(b, .{if (x) |_| a else b}); // failure
    try testFmt(b, .{if (x) |_| unreachable else b});

    x = c;
    // all pass
    try testFmt(c, .{if (x != null) x.? else b});
    try testFmt(c, .{if (x) |xx| xx else b});
    try testFmt(c, .{if (x) |_| x.? else b});
    try testFmt(a, .{if (x) |_| a else b});
    try testFmt(a, .{if (x) |_| a else unreachable});
}

[jakwings]

More cases:

test "wrong branching of if(runtime false) inside anonymous list literal" {
    const T = i32;
    var x: T = 0;
    const a: T = 0;
    const b: T = 1;

    try testFmt(a, .{if (true) a else b});
    try testFmt(b, .{if (false) a else b});
    try testFmt(a, .{if (yes(true)) a else b});
    try testFmt(b, .{if (no(false)) a else b}); // wrong
    try testFmt(b, .{if (no(false)) unreachable else b});
    //try testFmt(b, .{if (no(false)) a else unreachable}); // panic
    try testFmt(a, .{if (x == a) a else unreachable});
    try testFmt(b, .{if (x != a) unreachable else b});
    try testFmt(b, .{if (x == b) unreachable else b});
    try testFmt(a, .{if (x != b) a else unreachable});
    try testFmt(a, .{if (x == a) a else b});
    try testFmt(b, .{if (x != a) a else b}); // wrong
    try testFmt(b, .{if (x == b) a else b}); // wrong
    try testFmt(a, .{if (x != b) a else b});
    try testFmt(a, .{switch (x) { b => unreachable, a => a, else => unreachable }});
    try testFmt(a, .{switch (x) { b => b, a => a, else => unreachable }}); // wrong
    try testFmt(a, .{switch (x) { b => unreachable, a => a, else => b }}); // wrong
    try testFmt(a, .{switch (x) { a => a, b => unreachable, else => unreachable }});
    try testFmt(a, .{switch (x) { a => a, b => unreachable, else => b }}); // wrong
    try testFmt(a, .{switch (x) { a => a, b => b, else => unreachable }});
    try testFmt(a, .{switch (x) { a => a, b => b, else => b }}); // wrong
}
fn yes(t: var) bool {
    return true;
}
fn no(t: var) bool {
    return false;
}

[ghost]

const std = @import("std");

pub fn main() void {
    var x = false;
    std.debug.warn("{}\n", .{if (x) true else false}); // wrong
    std.debug.warn("{}\n", .{if (!x) false else true}); // right
}

true
false

Is it always taking the first branch?

[giatorta]

const std = @import("std");

pub fn main() void {
var x = false;
std.debug.warn("{}\n", .{if (x) true else false}); // wrong
std.debug.warn("{}\n", .{if (!x) false else true}); // right
}

true
false

just a small addition: putting "1>2" (resp. "1<2") instead of "x" (resp. "!x") in the if condition works correctly, i.e. prints "false" twice

[Vexu]

Duplicate of #3882