Add ability to determine if we are currently executing at compile time

[tiehuis]

I'm sure this was mentioned somewhere but could not find an issue: The gist is as follows:

if (@areWeInComptime()) {
   // use a slow fallback which we can compute in zig
} else {
   // use a fast runtime version that uses assembly (or features not supported at comptime)
}

This is present in D for example via the __ctfe variable. The current reason I need this is that I want to call sqrt at compile-time but on x86_64 this uses an assembly routine which can not be evaluated at compile-time.

[andrewrk]

I think this makes sense. One thing I want to avoid though is over-reliance on this. In most cases we should strive to make the runtime and comptime representation the same. Something that I never want to see is a function that could have been perfectly fine executing in both comptime and runtime contexts, but somebody didn't think that was possible and did something like if (@areWeInComptime()) @compileError("unsupported").

In the case of inline assembly for sqrt, see #767

[tiehuis]

Completely agree on not over-relying on this. I did forget about the llvm math intrinsics. I'm happy enough to hold of on this for now until we get other possible use cases that require something of this sort.

[andrewrk]

It's kind of a dirty secret that this is possible, but...

const std = @import("std");

test "detect comptime" {
    std.debug.warn("\n");
    std.debug.warn("1={}\n", isCompTime());
    std.debug.warn("2={}\n", comptime isCompTime());
    std.debug.warn("3={}\n", comptime isCompTime());
    std.debug.warn("4={}\n", isCompTime());
}

fn isCompTime() bool {
    var t: bool = true;
    const x = if (t) u7(0) else u8(0);
    return @typeOf(x) == u7;
}

Don't rely on this - zig reserves the right to make the if static if it can prove the value is compile-time known (which it should be able to do in this example with more sophisticated semantic analysis).