./lib/std/enums.zig:145:17: error: redundant comptime keyword in already comptime scope
    const len = comptime directEnumArrayLen(E, max_unused_slots);
                ^
./src/Zir.zig:130:31: note: referenced here
        @intCast(u32, Inst.Ref.typed_value_map.len);
                              ^
./src/Zir.zig:132:15: note: referenced here
    try writer.writeInstToStream(fs_file.writer(), main_struct_inst);
              ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:28:11: note: referenced here
        }).lenAsc;
          ^
./lib/std/comptime_string_map.zig:36:9: note: referenced here
        std.sort.sort(KV, &sorted_kvs, {}, lenAsc);
        ^
./lib/std/meta.zig:85:19: note: referenced here
        return map.get(str);
                  ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/sort.zig:213:20: note: referenced here
    var iterator = Iterator.init(items.len, 4);
                   ^
./lib/std/sort.zig:213:28: note: referenced here
    var iterator = Iterator.init(items.len, 4);
                           ^
./lib/std/sort.zig:124:30: note: referenced here
        const power_of_two = math.floorPowerOfTwo(usize, size2);
                             ^
./lib/std/sort.zig:124:34: note: referenced here
        const power_of_two = math.floorPowerOfTwo(usize, size2);
                                 ^
./lib/std/sort.zig:214:21: note: referenced here
    while (!iterator.finished()) {
                    ^
./lib/std/sort.zig:142:35: note: referenced here
    fn nextRange(self: *Iterator) Range {
                                  ^
./lib/std/sort.zig:216:31: note: referenced here
        const range = iterator.nextRange();
                              ^
./lib/std/sort.zig:219:22: note: referenced here
        switch (range.length()) {
                     ^
./lib/std/sort.zig:285:17: note: referenced here
                swap(T, sliced_items, context, lessThan, &order, 0, 1);
                ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/sort.zig:300:21: note: referenced here
        if (iterator.length() < cache.len) {
                    ^
./lib/std/sort.zig:304:25: note: referenced here
                iterator.begin();
                        ^
./lib/std/sort.zig:318:25: note: referenced here
                        mergeInto(T, items, A1, B1, context, lessThan, cache[0..]);
                        ^
./lib/std/sort.zig:327:31: note: referenced here
                    A1 = Range.init(A1.start, B1.end);
                              ^
./lib/std/sort.zig:364:29: note: referenced here
                _ = iterator.nextLevel();
                            ^
./lib/std/sort.zig:377:25: note: referenced here
                        mergeExternal(T, items, A, B, context, lessThan, cache[0..]);
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./src/translate_c.zig:4597:33: note: referenced here
    return @import("AstGen.zig").simple_types.has(name);
                                ^
./src/translate_c.zig:4597:46: note: referenced here
    return @import("AstGen.zig").simple_types.has(name);
                                             ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/enums.zig:145:17: error: redundant comptime keyword in already comptime scope
    const len = comptime directEnumArrayLen(E, max_unused_slots);
                ^
./src/Module.zig:3020:51: note: referenced here
                    const union_tag = Zir.Inst.Tag.data_tags[@enumToInt(tags[i])];
                                                  ^
./src/Module.zig:3021:49: note: referenced here
                    const as_struct = @ptrCast(*Stage1DataLayout, data);
                                                ^
./src/Module.zig:3043:41: note: referenced here
                    try mod.failed_files.putNoClobber(gpa, file, null);
                                        ^
./lib/std/array_hash_map.zig:413:70: note: referenced here
        pub fn getOrPut(self: *Self, allocator: *Allocator, key: K) !GetOrPutResult {
                                                                     ^
./lib/std/array_hash_map.zig:523:36: note: referenced here
            const result = try self.getOrPut(allocator, key);
                                   ^
./lib/std/array_hash_map.zig:414:17: note: referenced here
            self.ensureCapacity(allocator, self.entries.items.len + 1) catch |err| {
                ^
./lib/std/array_list.zig:617:36: note: referenced here
        pub const ensureCapacity = ensureTotalCapacity;
                                   ^
./lib/std/array_hash_map.zig:478:29: note: referenced here
            try self.entries.ensureCapacity(allocator, new_capacity);
                            ^
./lib/std/array_list.zig:630:65: note: referenced here
            const new_memory = try allocator.reallocAtLeast(self.allocatedSlice(), better_capacity);
                                                                ^
./lib/std/array_hash_map.zig:479:33: note: referenced here
            if (new_capacity <= linear_scan_max) return;
                                ^
./lib/std/array_hash_map.zig:490:25: note: referenced here
                    self.insertAllEntriesIntoNewHeader(new_header);
                        ^
./lib/std/array_hash_map.zig:416:35: note: referenced here
                const index = self.getIndex(key) orelse return err;
                                  ^
./lib/std/array_hash_map.zig:423:24: note: referenced here
            return self.getOrPutAssumeCapacity(key);
                       ^
./src/Module.zig:3087:8: note: referenced here
    mod.lockAndClearFileCompileError(file);
       ^
./src/Module.zig:3096:9: note: referenced here
    file.unload(gpa);
        ^
./src/Module.zig:3199:17: note: referenced here
    cache_file.?.writevAll(&iovecs) catch |err| {
                ^
./src/Compilation.zig:2212:17: note: referenced here
            comp.reportRetryableAstGenError(file, err) catch |oom| switch (oom) {
                ^
./src/Compilation.zig:2205:13: note: referenced here
    defer wg.finish();
            ^
./src/Compilation.zig:2236:31: note: referenced here
                break :blk mod.importFile(file, import_path) catch continue;
                              ^
./src/ThreadPool.zig:112:58: note: referenced here
        run_node: RunQueue.Node = .{ .data = .{ .runFn = runFn } },
                                                         ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./src/translate_c.zig:766:9: note: referenced here
    if (builtin_typedef_map.get(name)) |builtin| {
        ^
./src/translate_c.zig:766:28: note: referenced here
    if (builtin_typedef_map.get(name)) |builtin| {
                           ^
./src/clang.zig:904:29: note: referenced here
    pub const getLocation = ZigClangTypedefNameDecl_getLocation;
                            ^
./src/translate_c.zig:773:37: note: referenced here
    const typedef_loc = typedef_decl.getLocation();
                                    ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/c/tokenizer.zig:312:13: note: referenced here
        if (keywords.get(bytes)) |id| {
            ^
./lib/std/c/tokenizer.zig:312:21: note: referenced here
        if (keywords.get(bytes)) |id| {
                    ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/zig/tokenizer.zig:74:16: note: referenced here
        return keywords.get(bytes);
               ^
./lib/std/zig/tokenizer.zig:74:24: note: referenced here
        return keywords.get(bytes);
                       ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./src/BuiltinFn.zig:110:6: note: referenced here
tag: Tag,
     ^
./src/AstGen.zig:6440:27: note: referenced here
    const info = BuiltinFn.list.get(builtin_name) orelse {
                          ^
./src/AstGen.zig:6440:32: note: referenced here
    const info = BuiltinFn.list.get(builtin_name) orelse {
                               ^
./src/AstGen.zig:6467:31: note: referenced here
            try astgen.imports.put(astgen.gpa, str.index, {});
                              ^
./lib/std/array_hash_map.zig:516:36: note: referenced here
            const result = try self.getOrPut(allocator, key);
                                   ^
./src/AstGen.zig:6477:34: note: referenced here
            const result = try gz.addExtendedMultiOp(.compile_log, node, arg_refs);
                                 ^
./src/AstGen.zig:6494:31: note: referenced here
        .as         => return as(       gz, scope, rl, node, params[0], params[1]),
                              ^
./src/AstGen.zig:6495:31: note: referenced here
        .bit_cast   => return bitCast(  gz, scope, rl, node, params[0], params[1]),
                              ^
./src/AstGen.zig:6496:31: note: referenced here
        .TypeOf     => return typeOf(   gz, scope, rl, node, params),
                              ^
./src/AstGen.zig:6497:31: note: referenced here
        .union_init => return unionInit(gz, scope, rl, node, params),
                              ^
./src/AstGen.zig:6498:31: note: referenced here
        .c_import   => return cImport(  gz, scope, rl, node, params[0]),
                              ^
./src/AstGen.zig:6522:34: note: referenced here
            const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{
                                 ^
./src/AstGen.zig:6522:79: note: referenced here
            const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{
                                                                              ^
./src/AstGen.zig:6530:31: note: referenced here
        .breakpoint => return simpleNoOpVoid(gz, scope, rl, node, .breakpoint),
                              ^
./src/AstGen.zig:6533:67: note: referenced here
        .This               => return rvalue(gz, scope, rl, try gz.addNodeExtended(.this,               node), node),
                                                                  ^
./src/AstGen.zig:6540:32: note: referenced here
        .type_info   => return simpleUnOpType(gz, scope, rl, node, params[0], .type_info),
                               ^
./src/AstGen.zig:6545:42: note: referenced here
        .ptr_to_int            => return simpleUnOp(gz, scope, rl, node, .none,                           params[0], .ptr_to_int),
                                         ^
./src/AstGen.zig:6578:33: note: referenced here
        .float_to_int => return typeCast(gz, scope, rl, node, params[0], params[1], .float_to_int),
                                ^
./src/AstGen.zig:6597:30: note: referenced here
        .has_decl  => return hasDeclOrField(gz, scope, rl, node, params[0], params[1], .has_decl),
                             ^
./src/AstGen.zig:6600:32: note: referenced here
        .clz         => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .clz),
                               ^
./src/AstGen.zig:6606:30: note: referenced here
        .div_exact => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_exact),
                             ^
./src/AstGen.zig:6615:35: note: referenced here
        .bit_offset_of  => return offsetOf(gz, scope, rl, node, params[0], params[1], .bit_offset_of),
                                  ^
./src/AstGen.zig:6618:30: note: referenced here
        .c_undef   => return simpleCBuiltin(gz, scope, rl, node, params[0], .c_undef),
                             ^
./src/AstGen.zig:6621:35: note: referenced here
        .cmpxchg_strong => return cmpxchg(gz, scope, rl, node, params, .cmpxchg_strong),
                                  ^
./src/AstGen.zig:6626:81: note: referenced here
            const result = try gz.addExtendedPayload(.wasm_memory_size, Zir.Inst.UnNode{
                                                                                ^
./src/AstGen.zig:6672:38: note: referenced here
        .add_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .add_with_overflow),
                                     ^
./src/AstGen.zig:6733:72: note: referenced here
            const result = try gz.addPlNode(.atomic_rmw, node, Zir.Inst.AtomicRmw{
                                                                       ^
./src/AstGen.zig:6755:74: note: referenced here
            const result = try gz.addPlNode(.atomic_store, node, Zir.Inst.AtomicStore{
                                                                         ^
./src/AstGen.zig:6767:69: note: referenced here
            const result = try gz.addPlNode(.mul_add, node, Zir.Inst.MulAdd{
                                                                    ^
./src/AstGen.zig:6778:74: note: referenced here
            const result = try gz.addPlNode(.builtin_call, node, Zir.Inst.BuiltinCall{
                                                                         ^
./src/AstGen.zig:6789:78: note: referenced here
            const result = try gz.addPlNode(.field_parent_ptr, node, Zir.Inst.FieldParentPtr{
                                                                             ^
./src/AstGen.zig:6797:68: note: referenced here
            const result = try gz.addPlNode(.memcpy, node, Zir.Inst.Memcpy{
                                                                   ^
./src/AstGen.zig:6805:68: note: referenced here
            const result = try gz.addPlNode(.memset, node, Zir.Inst.Memset{
                                                                   ^
./src/AstGen.zig:6813:69: note: referenced here
            const result = try gz.addPlNode(.shuffle, node, Zir.Inst.Shuffle{
                                                                    ^
./src/AstGen.zig:6822:80: note: referenced here
            const result = try gz.addPlNode(.builtin_async_call, node, Zir.Inst.AsyncCall{
                                                                               ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^
./lib/std/comptime_string_map.zig:17:25: error: redundant comptime keyword in already comptime scope
    const precomputed = comptime blk: {
                        ^