comptime keyword used with runtime-known identifier fails to produce a compile error

[ghost]

fn hasField() bool {
    return false;
}

test "" {
    var x: u32 = 123; // runtime value

    // what i'm trying to do:
    if (comptime hasField()) {
      if (x == 123) {
        @compileError("A"); // this won't happen
      }
    }

    // this works as above, although it's weird and ambiguous to read
    if (comptime hasField() and x == 123) {
        @compileError("B"); // this won't happen
    }

    // this does not work as above. `comptime` seems to be ignored.
    if (x == 123 and comptime hasField()) {
        @compileError("C"); // this happens
    }
}

Output:

/home/dbandstra/zang/test.zig:22:9: error: C
        @compileError("C"); // this happens
        ^

Disclaimer: I don't actually know how this comptime thing works. I don't think it's even documented? Is it an official feature? (I find it useful.)

In the above test, I'm not sure what I expect to happen. In the first condition, comptime hasField() and x == 123, I don't whether comptime is supposed to apply to the first term or to the whole expression.

But in any case, I think there should be a compile error if a comptime is not going to be applied.

    var x: u32 = 123; // runtime value

    if (comptime x == 123) {
        std.debug.warn("why am i allowed to do this? what does it mean?\n");
    }

    var x: u32 = 123; // runtime value

    if (comptime x == 123 and comptime hasField()) {
        @compileError("huh?"); // this happens
    }

/home/dbandstra/zang/test.zig:9:20: error: unable to evaluate constant expression
    if (comptime x == 123 and comptime hasField()) {
                   ^

[andrewrk]

Here's what's happening in each of your examples:

    if (comptime hasField()) {

comptime causes hasField to be evaluated at compile-time. Result is a compile-time known bool. The if is evaluated at compile-time.

    if (comptime hasField() and x == 123) {

Perhaps related to #114, this is parsed as (comptime hasField()) and x == 123 and not comptime (hasField() and x == 123). However because and does not evaluate the right-hand side if the left-hand side is comptime-known, the x == 123 is never evaluated.

    if (x == 123 and comptime hasField()) {

x == 123 is a runtime-known value, so even though comptime hasField() is evaluated to false, both sides of the if statement must be generated, which means that @compileError("C"); is reachable.

const std = @import("std");

test "aoeu" {
    var x: u32 = 123; // runtime value

    if (comptime x == 123) {
        std.debug.warn("why am i allowed to do this? what does it mean?\n", .{});
    }
}

This is a bug. If the expression is used in another context where a comptime value is required, you get a compilation error as expected:

const std = @import("std");

test "aoeu" {
    var x: u32 = 123; // runtime value
    var y: [@boolToInt(x == 123)]u8 = undefined;
}

/home/andy/dev/zig/build/test.zig:5:13: error: unable to evaluate constant expression
    var y: [@boolToInt(x == 123)]u8 = undefined;
            ^

This compile error is correct; the other case is incorrectly missing the compile error.

[nektro]

this affects stage2 as well

[andrewrk]

The only issue here is this:

const std = @import("std");

test "comptime keyword used on runtime-known variable" {
    var x: u32 = 123; // runtime value

    if (comptime x == 123) { // should be a compile error because `x` is runtime-known
        return error.TestFailed;
    }
}

$ stage4/bin/zig test test.zig 
Test [1/1] test.comptime keyword used on runtime-known variable... FAIL (TestFailed)
/home/andy/dev/zig/build-release/test.zig:7:9: 0x20bed1 in test.comptime keyword used on runtime-known variable (test)
        return error.TestFailed;
        ^
0 passed; 0 skipped; 1 failed.
error: the following test command failed with exit code 1:
/home/andy/dev/zig/zig-cache/o/946dc69dfede9bc2cbf0db64615fb63d/test

[Vexu]

Fixed by #13360 and #14819