missing comptime undefined propagation for equality operator with pointer, optional, error union, and integers

[Jarred-Sumner]

The following strictly always is undefined behavior that Zig chooses to compile successfully:

Checking if a value is not equal to undefined:

pub fn deinit(this: *@This()) void {
   if (this.context != undefined) {
    this.allocator.destroy(this.context);
  }
}

Checking if a value is equal to undefined:

pub fn deinit(this: *@This()) void {
   if (this.context == undefined) {
    this.allocator.destroy(this.context);
  }
}

Why isn't this a compiler error?

[Jarred-Sumner]

Similarly, this test passes in a debug build. It should be a compiler error?

test {
    var foo: ?*bar.baz.Foo = undefined;
    if (foo != null and foo != undefined) {
        @import("std").debug.print("wat", .{});
    }
}

[andrewrk]

New test case

test "undefined propagation in equality operators for bool" {
    var foo: bool = undefined;
    if (foo == undefined) {}
}

test "undefined propagation in equality operators for pointer" {
    var foo: *i32 = undefined;
    if (foo == undefined) {}
}

test "undefined propagation in equality operators for optional" {
    var foo: ?*i32 = undefined;
    if (foo == undefined) {}
}

test "undefined propagation in equality operators for error union" {
    var foo: anyerror = undefined;
    if (foo == @as(anyerror!i32, undefined)) {}
}

test "undefined propagation in equality operators for integers" {
    var foo: i32 = undefined;
    if (foo == undefined) {}
}

Observed output:

test.zig:3:13: error: use of undefined value here causes undefined behavior
    if (foo == undefined) {}
        ~~~~^~~~~~~~~~~~

Expected output

The boolean one is correct. The compile error is missing for all the other cases.

Getting started

Start here at Sema.zig line 1031:

            .cmp_lt                       => try sema.zirCmp(block, inst, .lt),
            .cmp_lte                      => try sema.zirCmp(block, inst, .lte),
            .cmp_eq                       => try sema.zirCmpEq(block, inst, .eq, Air.Inst.Tag.fromCmpOp(.eq, block.float_mode == .Optimized)),
            .cmp_gte                      => try sema.zirCmp(block, inst, .gte),
            .cmp_gt                       => try sema.zirCmp(block, inst, .gt),
            .cmp_neq                      => try sema.zirCmpEq(block, inst, .neq, Air.Inst.Tag.fromCmpOp(.neq, block.float_mode == .Optimized)),

Follow that logic to zirCmpEq and you can see where it goes wrong. The comparison operation needs to make sure the result is a comptime value known to be undefined so that the compile error in the branch condition catches it.

[andrewrk]

Fix reverted in 70d8baa.