Commit 6ea3d3e19fce2317e8d7e60a78307f16f2538d72 | zig

src/Sema.zig+109-29

 @@ -1917,6 +1917,7 @@ fn resolveMaybeUndefValAllowVariablesMaybeRuntime(
             const ty_pl = sema.air_instructions.items(.data)[i].ty_pl;
             const val = sema.air_values.items[ty_pl.payload];
             if (val.tag() == .runtime_value) make_runtime.* = true;
+            if (val.isPtrToThreadLocal(sema.mod)) make_runtime.* = true;
             return val;
         },
         .const_ty => {
 @@ -4380,7 +4381,7 @@ fn zirValidateArrayInit(
         var block_index = block.instructions.items.len - 1;
         while (block.instructions.items[block_index] != elem_ptr_air_inst) {
             if (block_index == 0) {
-                array_is_comptime = true;
+                array_is_comptime = false;
                 continue :outer;
             }
             block_index -= 1;
 @@ -10343,6 +10344,9 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         }
         if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, special.body, operand);
         if (special.is_inline) child_block.inline_case_capture = operand;
+        if (empty_enum) {
+            return Air.Inst.Ref.void_value;
+        }
         return sema.resolveBlockBody(block, src, &child_block, special.body, inst, merges);
     }
 @@ -11992,10 +11996,18 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const element_vals = try sema.arena.alloc(Value, final_len_including_sent);
             var elem_i: usize = 0;
             while (elem_i < lhs_len) : (elem_i += 1) {
-                element_vals[elem_i] = try lhs_sub_val.elemValue(sema.mod, sema.arena, elem_i);
+                const elem_val = try lhs_sub_val.elemValue(sema.mod, sema.arena, elem_i);
+                const elem_val_inst = try sema.addConstant(lhs_info.elem_type, elem_val);
+                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
+                const coereced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
+                element_vals[elem_i] = coereced_elem_val;
             }
             while (elem_i < result_len) : (elem_i += 1) {
-                element_vals[elem_i] = try rhs_sub_val.elemValue(sema.mod, sema.arena, elem_i - lhs_len);
+                const elem_val = try rhs_sub_val.elemValue(sema.mod, sema.arena, elem_i - lhs_len);
+                const elem_val_inst = try sema.addConstant(lhs_info.elem_type, elem_val);
+                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
+                const coereced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
+                element_vals[elem_i] = coereced_elem_val;
             }
             if (res_sent_val) |sent_val| {
                 element_vals[result_len] = sent_val;
 @@ -12469,10 +12481,12 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
             if (maybe_rhs_val) |rhs_val| {
                 if (is_int) {
-                    return sema.addConstant(
+                    const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target);
-                        resolved_type,
+                    var vector_index: usize = undefined;
-                        try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target),
+                    if (!(try sema.intFitsInType(block, src, res, resolved_type, &vector_index))) {
-                    );
+                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vector_index);
+                    }
+                    return sema.addConstant(resolved_type, res);
                 } else {
                     return sema.addConstant(
                         resolved_type,
 @@ -12584,10 +12598,12 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     if (modulus_val.compareWithZero(.neq)) {
                         return sema.fail(block, src, "exact division produced remainder", .{});
                     }
-                    return sema.addConstant(
+                    const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target);
-                        resolved_type,
+                    var vector_index: usize = undefined;
-                        try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target),
+                    if (!(try sema.intFitsInType(block, src, res, resolved_type, &vector_index))) {
-                    );
+                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vector_index);
+                    }
+                    return sema.addConstant(resolved_type, res);
                 } else {
                     const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, target);
                     if (modulus_val.compareWithZero(.neq)) {
 @@ -12862,10 +12878,12 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             if (maybe_rhs_val) |rhs_val| {
                 if (is_int) {
-                    return sema.addConstant(
+                    const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target);
-                        resolved_type,
+                    var vector_index: usize = undefined;
-                        try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target),
+                    if (!(try sema.intFitsInType(block, src, res, resolved_type, &vector_index))) {
-                    );
+                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vector_index);
+                    }
+                    return sema.addConstant(resolved_type, res);
                 } else {
                     return sema.addConstant(
                         resolved_type,
 @@ -22457,7 +22475,10 @@ fn fieldVal(
                     } else (try sema.mod.getErrorValue(field_name)).key;
                     return sema.addConstant(
-                        try child_type.copy(arena),
+                        if (!child_type.isAnyError())
+                            try child_type.copy(arena)
+                        else
+                            try Type.Tag.error_set_single.create(arena, name),
                         try Value.Tag.@"error".create(arena, .{ .name = name }),
                     );
                 },
 @@ -22668,7 +22689,10 @@ fn fieldPtr(
                     var anon_decl = try block.startAnonDecl(src);
                     defer anon_decl.deinit();
                     return sema.analyzeDeclRef(try anon_decl.finish(
-                        try child_type.copy(anon_decl.arena()),
+                        if (!child_type.isAnyError())
+                            try child_type.copy(anon_decl.arena())
+                        else
+                            try Type.Tag.error_set_single.create(anon_decl.arena(), name),
                         try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
                         0, // default alignment
                     ));
 @@ -22827,6 +22851,7 @@ fn fieldCallBind(
                     {
                         const first_param_type = decl_type.fnParamType(0);
                         const first_param_tag = first_param_type.tag();
+                        var opt_buf: Type.Payload.ElemType = undefined;
                         // zig fmt: off
                         if (first_param_tag == .var_args_param or
                             first_param_tag == .generic_poison or (
 @@ -22845,7 +22870,27 @@ fn fieldCallBind(
                             });
                             return sema.addConstant(ty, value);
                         } else if (first_param_type.eql(concrete_ty, sema.mod)) {
-                            var deref = try sema.analyzeLoad(block, src, object_ptr, src);
+                            const deref = try sema.analyzeLoad(block, src, object_ptr, src);
+                            const ty = Type.Tag.bound_fn.init();
+                            const value = try Value.Tag.bound_fn.create(arena, .{
+                                .func_inst = decl_val,
+                                .arg0_inst = deref,
+                            });
+                            return sema.addConstant(ty, value);
+                        } else if (first_param_tag != .generic_poison and first_param_type.zigTypeTag() == .Optional and
+                            first_param_type.optionalChild(&opt_buf).eql(concrete_ty, sema.mod))
+                        {
+                            const deref = try sema.analyzeLoad(block, src, object_ptr, src);
+                            const ty = Type.Tag.bound_fn.init();
+                            const value = try Value.Tag.bound_fn.create(arena, .{
+                                .func_inst = decl_val,
+                                .arg0_inst = deref,
+                            });
+                            return sema.addConstant(ty, value);
+                        } else if (first_param_tag != .generic_poison and first_param_type.zigTypeTag() == .ErrorUnion and
+                            first_param_type.errorUnionPayload().eql(concrete_ty, sema.mod))
+                        {
+                            const deref = try sema.analyzeLoad(block, src, object_ptr, src);
                             const ty = Type.Tag.bound_fn.init();
                             const value = try Value.Tag.bound_fn.create(arena, .{
                                 .func_inst = decl_val,
 @@ -28763,6 +28808,13 @@ fn resolvePeerTypes(
                             }
                         }
                     },
+                    .Fn => {
+                        if (!cand_info.mutable and cand_info.pointee_type.zigTypeTag() == .Fn and .ok == try sema.coerceInMemoryAllowedFns(block, chosen_ty, cand_info.pointee_type, target, src, src)) {
+                            chosen = candidate;
+                            chosen_i = candidate_i + 1;
+                            continue;
+                        }
+                    },
                     else => {},
                 }
             },
 @@ -28793,6 +28845,11 @@ fn resolvePeerTypes(
                 .Vector => continue,
                 else => {},
             },
+            .Fn => if (chosen_ty.isSinglePointer() and chosen_ty.isConstPtr() and chosen_ty.childType().zigTypeTag() == .Fn) {
+                if (.ok == try sema.coerceInMemoryAllowedFns(block, chosen_ty.childType(), candidate_ty, target, src, src)) {
+                    continue;
+                }
+            },
             else => {},
         }
 @@ -30440,23 +30497,23 @@ pub fn typeHasOnePossibleValue(
             if (enum_obj.tag_ty.hasRuntimeBits()) {
                 return null;
             }
-            if (enum_obj.fields.count() == 1) {
+            switch (enum_obj.fields.count()) {
-                if (enum_obj.values.count() == 0) {
+                0 => return Value.initTag(.unreachable_value),
+                1 => if (enum_obj.values.count() == 0) {
                     return Value.zero; // auto-numbered
                 } else {
                     return enum_obj.values.keys()[0];
-                }
+                },
-            } else {
+                else => return null,
-                return null;
             }
         },
         .enum_simple => {
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const enum_simple = resolved_ty.castTag(.enum_simple).?.data;
-            if (enum_simple.fields.count() == 1) {
+            switch (enum_simple.fields.count()) {
-                return Value.zero;
+                0 => return Value.initTag(.unreachable_value),
-            } else {
+                1 => return Value.zero,
-                return null;
+                else => return null,
             }
         },
         .enum_nonexhaustive => {
 @@ -30473,7 +30530,7 @@ pub fn typeHasOnePossibleValue(
             const tag_val = (try sema.typeHasOnePossibleValue(block, src, union_obj.tag_ty)) orelse
                 return null;
             const fields = union_obj.fields.values();
-            if (fields.len == 0) return Value.initTag(.empty_struct_value);
+            if (fields.len == 0) return Value.initTag(.unreachable_value);
             const only_field = fields[0];
             if (only_field.ty.eql(resolved_ty, sema.mod)) {
                 const msg = try Module.ErrorMsg.create(
 @@ -32036,15 +32093,36 @@ fn elemPtrType(sema: *Sema, ptr_ty: Type, offset: ?usize) !Type {
     const ptr_info = ptr_ty.ptrInfo().data;
     const elem_ty = ptr_ty.elemType2();
     const allow_zero = ptr_info.@"allowzero" and (offset orelse 0) == 0;
+    const target = sema.mod.getTarget();
+    const parent_ty = ptr_ty.childType();
+    const vector_info: struct {
+        host_size: u16,
+        bit_offset: u16,
+        alignment: u32,
+    } = if (parent_ty.tag() == .vector) blk: {
+        const elem_bits = elem_ty.bitSize(target);
+        const is_packed = elem_bits != 0 and (elem_bits & (elem_bits - 1)) != 0;
+        // TODO: runtime-known index
+        assert(!is_packed or offset != null);
+        const is_packed_with_offset = is_packed and offset != null and offset.? != 0;
+        const target_offset = if (is_packed_with_offset) (if (target.cpu.arch.endian() == .Big) (parent_ty.vectorLen() - 1 - offset.?) else offset.?) else 0;
+        break :blk .{
+            .host_size = if (is_packed_with_offset) @intCast(u16, parent_ty.abiSize(target)) else 0,
+            .bit_offset = if (is_packed_with_offset) @intCast(u16, elem_bits * target_offset) else 0,
+            .alignment = if (is_packed_with_offset) @intCast(u16, parent_ty.abiAlignment(target)) else 0,
+        };
+    } else .{ .host_size = 0, .bit_offset = 0, .alignment = 0 };
     const alignment: u32 = a: {
         // Calculate the new pointer alignment.
         if (ptr_info.@"align" == 0) {
+            if (vector_info.alignment != 0) break :a vector_info.alignment;
             // ABI-aligned pointer. Any pointer arithmetic maintains the same ABI-alignedness.
             break :a 0;
         }
         // If the addend is not a comptime-known value we can still count on
         // it being a multiple of the type size.
-        const target = sema.mod.getTarget();
         const elem_size = elem_ty.abiSize(target);
         const addend = if (offset) |off| elem_size * off else elem_size;
 @@ -32061,5 +32139,7 @@ fn elemPtrType(sema: *Sema, ptr_ty: Type, offset: ?usize) !Type {
         .@"allowzero" = allow_zero,
         .@"volatile" = ptr_info.@"volatile",
         .@"align" = alignment,
+        .host_size = vector_info.host_size,
+        .bit_offset = vector_info.bit_offset,
     });
 }

src/type.zig+16-17

 @@ -3574,15 +3574,13 @@ pub const Type = extern union {
             .u128, .i128, .f128 => return 128,
             .@"struct" => {
-                if (sema_kit) |sk| _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty);
+                const struct_obj = ty.castTag(.@"struct").?.data;
-                if (ty.containerLayout() != .Packed) {
+                if (struct_obj.layout != .Packed) {
                     return (try ty.abiSizeAdvanced(target, if (sema_kit) |sk| .{ .sema_kit = sk } else .eager)).scalar * 8;
                 }
-                var total: u64 = 0;
+                if (sema_kit) |sk| _ = try sk.sema.resolveTypeLayout(sk.block, sk.src, ty);
-                for (ty.structFields().values()) |field| {
+                assert(struct_obj.haveLayout());
-                    total += try bitSizeAdvanced(field.ty, target, sema_kit);
+                return try struct_obj.backing_int_ty.bitSizeAdvanced(target, sema_kit);
-                }
-                return total;
             },
             .tuple, .anon_struct => {
 @@ -5015,22 +5013,22 @@ pub const Type = extern union {
                 if (enum_full.tag_ty.hasRuntimeBits()) {
                     return null;
                 }
-                if (enum_full.fields.count() == 1) {
+                switch (enum_full.fields.count()) {
-                    if (enum_full.values.count() == 0) {
+                    0 => return Value.initTag(.unreachable_value),
-                        return Value.zero;
+                    1 => if (enum_full.values.count() == 0) {
+                        return Value.zero; // auto-numbered
                     } else {
                         return enum_full.values.keys()[0];
-                    }
+                    },
-                } else {
+                    else => return null,
-                    return null;
                 }
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                if (enum_simple.fields.count() == 1) {
+                switch (enum_simple.fields.count()) {
-                    return Value.zero;
+                    0 => return Value.initTag(.unreachable_value),
-                } else {
+                    1 => return Value.zero,
-                    return null;
+                    else => return null,
                 }
             },
             .enum_nonexhaustive => {
 @@ -5044,6 +5042,7 @@ pub const Type = extern union {
             .@"union", .union_safety_tagged, .union_tagged => {
                 const union_obj = ty.cast(Payload.Union).?.data;
                 const tag_val = union_obj.tag_ty.onePossibleValue() orelse return null;
+                if (union_obj.fields.count() == 0) return Value.initTag(.unreachable_value);
                 const only_field = union_obj.fields.values()[0];
                 const val_val = only_field.ty.onePossibleValue() orelse return null;
                 _ = tag_val;

src/value.zig+23

...	@@ -2806,6 +2806,29 @@ pub const Value = extern union {	...	@@ -2806,6 +2806,29 @@ pub const Value = extern union {
2806	};	2806	};
2807	}	2807	}
2808		2808
		2809	pub fn isPtrToThreadLocal(val: Value, mod: *Module) bool {
		2810	return switch (val.tag()) {
		2811	.variable => false,
		2812	else => val.isPtrToThreadLocalInner(mod),
		2813	};
		2814	}
		2815
		2816	fn isPtrToThreadLocalInner(val: Value, mod: *Module) bool {
		2817	return switch (val.tag()) {
		2818	.slice => val.castTag(.slice).?.data.ptr.isPtrToThreadLocalInner(mod),
		2819	.comptime_field_ptr => val.castTag(.comptime_field_ptr).?.data.field_val.isPtrToThreadLocalInner(mod),
		2820	.elem_ptr => val.castTag(.elem_ptr).?.data.array_ptr.isPtrToThreadLocalInner(mod),
		2821	.field_ptr => val.castTag(.field_ptr).?.data.container_ptr.isPtrToThreadLocalInner(mod),
		2822	.eu_payload_ptr => val.castTag(.eu_payload_ptr).?.data.container_ptr.isPtrToThreadLocalInner(mod),
		2823	.opt_payload_ptr => val.castTag(.opt_payload_ptr).?.data.container_ptr.isPtrToThreadLocalInner(mod),
		2824	.decl_ref => mod.declPtr(val.castTag(.decl_ref).?.data).val.isPtrToThreadLocalInner(mod),
		2825	.decl_ref_mut => mod.declPtr(val.castTag(.decl_ref_mut).?.data.decl_index).val.isPtrToThreadLocalInner(mod),
		2826
		2827	.variable => val.castTag(.variable).?.data.is_threadlocal,
		2828	else => false,
		2829	};
		2830	}
		2831
2809	// Asserts that the provided start/end are in-bounds.	2832	// Asserts that the provided start/end are in-bounds.
2810	pub fn sliceArray(	2833	pub fn sliceArray(
2811	val: Value,	2834	val: Value,

test/behavior/array.zig+22

...	@@ -574,3 +574,25 @@ test "tuple to array handles sentinel" {	...	@@ -574,3 +574,25 @@ test "tuple to array handles sentinel" {
574	};	574	};
575	try expect(S.b[0] == 1);	575	try expect(S.b[0] == 1);
576	}	576	}
		577
		578	test "array init of container level array variable" {
		579	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		580	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		581	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		582
		583	const S = struct {
		584	var pair: [2]usize = .{ 1, 2 };
		585	noinline fn foo(x: usize, y: usize) void {
		586	pair = [2]usize{ x, y };
		587	}
		588	noinline fn bar(x: usize, y: usize) void {
		589	var tmp: [2]usize = .{ x, y };
		590	pair = tmp;
		591	}
		592	};
		593	try expectEqual([2]usize{ 1, 2 }, S.pair);
		594	S.foo(3, 4);
		595	try expectEqual([2]usize{ 3, 4 }, S.pair);
		596	S.bar(5, 6);
		597	try expectEqual([2]usize{ 5, 6 }, S.pair);
		598	}

test/behavior/cast.zig+10

...	@@ -1419,3 +1419,13 @@ test "floatToInt to zero-bit int" {	...	@@ -1419,3 +1419,13 @@ test "floatToInt to zero-bit int" {
1419	var a: f32 = 0.0;	1419	var a: f32 = 0.0;
1420	comptime try std.testing.expect(@floatToInt(u0, a) == 0);	1420	comptime try std.testing.expect(@floatToInt(u0, a) == 0);
1421	}	1421	}
		1422
		1423	test "peer type resolution of function pointer and function body" {
		1424	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
		1425
		1426	const T = fn () u32;
		1427	const a: T = undefined;
		1428	const b: *const T = undefined;
		1429	try expect(@TypeOf(a, b) == *const fn () u32);
		1430	try expect(@TypeOf(b, a) == *const fn () u32);
		1431	}

test/behavior/empty_union.zig+18

...	@@ -48,3 +48,21 @@ test "empty extern union" {	...	@@ -48,3 +48,21 @@ test "empty extern union" {
48	try expect(@sizeOf(U) == 0);	48	try expect(@sizeOf(U) == 0);
49	try expect(@alignOf(U) == 1);	49	try expect(@alignOf(U) == 1);
50	}	50	}
		51
		52	test "empty union passed as argument" {
		53	const U = union(enum) {
		54	fn f(u: @This()) void {
		55	switch (u) {}
		56	}
		57	};
		58	U.f(@as(U, undefined));
		59	}
		60
		61	test "empty enum passed as argument" {
		62	const E = enum {
		63	fn f(e: @This()) void {
		64	switch (e) {}
		65	}
		66	};
		67	E.f(@as(E, undefined));
		68	}

test/behavior/error.zig+10

...	@@ -855,3 +855,13 @@ test "error from comptime string" {	...	@@ -855,3 +855,13 @@ test "error from comptime string" {
855	try expect(mem.eql(u8, name, @errorName(err)));	855	try expect(mem.eql(u8, name, @errorName(err)));
856	}	856	}
857	}	857	}
		858
		859	test "field access of anyerror results in smaller error set" {
		860	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
		861
		862	const E1 = @TypeOf(error.Foo);
		863	try expect(@TypeOf(E1.Foo) == E1);
		864	const E2 = error{ A, B, C };
		865	try expect(@TypeOf(E2.A) == E2);
		866	try expect(@TypeOf(@field(anyerror, "NotFound")) == error{NotFound});
		867	}

test/behavior/eval.zig+11

...	@@ -1488,3 +1488,14 @@ test "x or true is comptime-known true" {	...	@@ -1488,3 +1488,14 @@ test "x or true is comptime-known true" {
1488	}	1488	}
1489	try expect(T.x == 3);	1489	try expect(T.x == 3);
1490	}	1490	}
		1491
		1492	test "non-optional and optional array elements concatenated" {
		1493	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		1494	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		1495	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1496	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		1497
		1498	const array = [1]u8{'A'} ++ [1]?u8{null};
		1499	var index: usize = 0;
		1500	try expect(array[index].? == 'A');
		1501	}

test/behavior/fn.zig+19

...	@@ -434,3 +434,22 @@ test "implicit cast function to function ptr" {	...	@@ -434,3 +434,22 @@ test "implicit cast function to function ptr" {
434	var fnPtr2: *const fn () callconv(.C) c_int = S2.someFunctionThatReturnsAValue;	434	var fnPtr2: *const fn () callconv(.C) c_int = S2.someFunctionThatReturnsAValue;
435	try expect(fnPtr2() == 123);	435	try expect(fnPtr2() == 123);
436	}	436	}
		437
		438	test "method call with optional and error union first param" {
		439	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		441
		442	const S = struct {
		443	x: i32 = 1234,
		444
		445	fn opt(s: ?@This()) !void {
		446	try expect(s.?.x == 1234);
		447	}
		448	fn errUnion(s: anyerror!@This()) !void {
		449	try expect((try s).x == 1234);
		450	}
		451	};
		452	var s: S = .{};
		453	try s.opt();
		454	try s.errUnion();
		455	}

test/cases/compile_errors/address_of_threadlocal_not_comptime_known.zig created+13

...	@@ -0,0 +1,13 @@
1	threadlocal var global: u32 = 23;
2	threadlocal var global_ptr: *u32 = &global;
3
4	pub export fn entry() void {
5	if (global_ptr.* != 23) unreachable;
6	}
7
8	// error
9	// backend=stage2
10	// target=native
11	//
12	// :2:36: error: unable to resolve comptime value
13	// :2:36: note: container level variable initializers must be comptime-known

test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig created+13

...	@@ -0,0 +1,13 @@
1	const Foo = packed struct(u32) {
2	x: u1,
3	};
4	fn bar(_: Foo) callconv(.C) void {}
5	pub export fn entry() void {
6	bar(.{ .x = 0 });
7	}
8
9	// error
10	// backend=stage2
11	// target=native
12	//
13	// :1:27: error: backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 1

test/cases/compile_errors/div_overflow.zig created+11

...	@@ -0,0 +1,11 @@
1	comptime {
2	const a = -128;
3	const b: i8 = -1;
4	_ = a / b;
5	}
6
7	// error
8	// backend=stage2
9	// target=native
10	//
11	// :4:11: error: overflow of integer type 'i8' with value '128'

author	Veikka Tuominen <git@vexu.eu> 2022-11-07 14:17:26+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-01-09 13:52:37-07:00
log	6ea3d3e19fce2317e8d7e60a78307f16f2538d72
tree	be0d8fd8353e7bef9295f59bf86042fc4c2f7935
parent	6a94bcbbc6fdd4cd33981f924a7bd27773889e53

Merge pull request #13446 from Vexu/stage2-fixes