Add @inComptime builtin

Resolves: ziglang#868

src/AstGen.zig

@@ -8174,6 +8174,7 @@ fn builtinCall(
         .frame              => return rvalue(gz, ri, try gz.addNodeExtended(.frame,              node), node),
         .frame_address      => return rvalue(gz, ri, try gz.addNodeExtended(.frame_address,      node), node),
         .breakpoint         => return rvalue(gz, ri, try gz.addNodeExtended(.breakpoint,         node), node),
+        .in_comptime        => return rvalue(gz, ri, try gz.addNodeExtended(.in_comptime,        node), node),
 
         .type_info   => return simpleUnOpType(gz, scope, ri, node, params[0], .type_info),
         .size_of     => return simpleUnOpType(gz, scope, ri, node, params[0], .size_of),
@@ -8215,6 +8216,7 @@ fn builtinCall(
         .int_cast     => return typeCast(gz, scope, ri, node, params[0], params[1], .int_cast),
         .ptr_cast     => return typeCast(gz, scope, ri, node, params[0], params[1], .ptr_cast),
         .truncate     => return typeCast(gz, scope, ri, node, params[0], params[1], .truncate),
+
         // zig fmt: on
 
         .Type => {

src/BuiltinFn.zig

@@ -58,6 +58,7 @@ pub const Tag = enum {
     has_decl,
     has_field,
     import,
+    in_comptime,
     int_cast,
     int_to_enum,
     int_to_error,
@@ -560,6 +561,13 @@ pub const list = list: {
                 .param_count = 1,
             },
         },
+        .{
+            "@inComptime",
+            .{
+                .tag = .in_comptime,
+                .param_count = 0,
+            },
+        },
         .{
             "@intCast",
             .{

src/Sema.zig

@@ -1166,6 +1166,7 @@ fn analyzeBodyInner(
                     .work_item_id          => try sema.zirWorkItem(          block, extended, extended.opcode),
                     .work_group_size       => try sema.zirWorkItem(          block, extended, extended.opcode),
                     .work_group_id         => try sema.zirWorkItem(          block, extended, extended.opcode),
+                    .in_comptime           => try sema.zirInComptime(        block),
                     // zig fmt: on
 
                     .fence => {
@@ -22464,6 +22465,13 @@ fn zirWorkItem(
     });
 }
 
+fn zirInComptime(
+    sema: *Sema,
+    block: *Block,
+) CompileError!Air.Inst.Ref {
+    return sema.addConstant(Type.bool, if (block.is_comptime) Value.true else Value.false);
+}
+
 fn requireRuntimeBlock(sema: *Sema, block: *Block, src: LazySrcLoc, runtime_src: ?LazySrcLoc) !void {
     if (block.is_comptime) {
         const msg = msg: {

src/Zir.zig

@@ -1994,10 +1994,10 @@ pub const Inst = struct {
         /// Implement builtin `@cVaArg`.
         /// `operand` is payload index to `BinNode`.
         c_va_arg,
-        /// Implement builtin `@cVaStart`.
+        /// Implement builtin `@cVaCopy`.
         /// `operand` is payload index to `UnNode`.
         c_va_copy,
-        /// Implement builtin `@cVaStart`.
+        /// Implement builtin `@cVaEnd`.
         /// `operand` is payload index to `UnNode`.
         c_va_end,
         /// Implement builtin `@cVaStart`.
@@ -2018,6 +2018,9 @@ pub const Inst = struct {
         /// Implements the `@workGroupId` builtin.
         /// `operand` is payload index to `UnNode`.
         work_group_id,
+        /// Implements the `@inComptime` builtin.
+        /// `operand` is `src_node: i32`.
+        in_comptime,
 
         pub const InstData = struct {
             opcode: Extended,

src/print_zir.zig

@@ -466,6 +466,7 @@ const Writer = struct {
             .frame_address,
             .breakpoint,
             .c_va_start,
+            .in_comptime,
             => try self.writeExtNode(stream, extended),
 
             .builtin_src => {

test/behavior/eval.zig

@@ -1649,3 +1649,15 @@ test "early exit in container level const" {
     };
     try expect(S.value == 1);
 }
+
+test "@inComptime" {
+    const S = struct {
+        fn inComptime() bool {
+            return @inComptime();
+        }
+    };
+    try expectEqual(false, @inComptime());
+    try expectEqual(true, comptime @inComptime());
+    try expectEqual(false, S.inComptime());
+    try expectEqual(true, comptime S.inComptime());
+}