authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-26 00:33:14-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-26 00:33:14-07:00
logaf844931b2600e50e586436dee0d607d67ed9ff2
treec76003ccb51808c017ad6401d617729847f4ffa7
parent6ef761307ce286f4c6955ce2e7627e9a0d6ec442

stage2: resolve types more lazily

This avoids unwanted "foo depends on itself" compilation errors.

4 files changed, 118 insertions(+), 94 deletions(-)

src/Module.zig+5-1
......@@ -3904,7 +3904,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
39043904 // Note this resolves the type of the Decl, not the value; if this Decl
39053905 // is a struct, for example, this resolves `type` (which needs no resolution),
39063906 // not the struct itself.
3907 try sema.resolveTypeFully(&block_scope, src, decl_tv.ty);
3907 try sema.resolveTypeLayout(&block_scope, src, decl_tv.ty);
39083908
39093909 const decl_arena_state = try decl_arena_allocator.create(std.heap.ArenaAllocator.State);
39103910
......@@ -4049,6 +4049,10 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
40494049 if (has_runtime_bits) {
40504050 log.debug("queue linker work for {*} ({s})", .{ decl, decl.name });
40514051
4052 // Needed for codegen_decl which will call updateDecl and then the
4053 // codegen backend wants full access to the Decl Type.
4054 try sema.resolveTypeFully(&block_scope, src, decl.ty);
4055
40524056 try mod.comp.bin_file.allocateDeclIndexes(decl);
40534057 try mod.comp.work_queue.writeItem(.{ .codegen_decl = decl });
40544058
src/Sema.zig+6-10
......@@ -10880,9 +10880,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1088010880 .Pointer => {
1088110881 const info = ty.ptrInfo().data;
1088210882 const alignment = if (info.@"align" != 0)
10883 info.@"align"
10883 try Value.Tag.int_u64.create(sema.arena, info.@"align")
1088410884 else
10885 try sema.typeAbiAlignment(block, src, info.pointee_type);
10885 try info.pointee_type.lazyAbiAlignment(target, sema.arena);
1088610886
1088710887 const field_values = try sema.arena.create([8]Value);
1088810888 field_values.* = .{
......@@ -10893,7 +10893,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1089310893 // is_volatile: bool,
1089410894 Value.makeBool(info.@"volatile"),
1089510895 // alignment: comptime_int,
10896 try Value.Tag.int_u64.create(sema.arena, alignment),
10896 alignment,
1089710897 // address_space: AddressSpace
1089810898 try Value.Tag.enum_field_index.create(sema.arena, @enumToInt(info.@"addrspace")),
1089910899 // child: type,
......@@ -11322,8 +11322,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1132211322 const is_comptime = field_val.tag() != .unreachable_value;
1132311323 const opt_default_val = if (is_comptime) field_val else null;
1132411324 const default_val_ptr = try sema.optRefValue(block, src, field_ty, opt_default_val);
11325 const alignment = field_ty.abiAlignment(target);
11326
1132711325 struct_field_fields.* = .{
1132811326 // name: []const u8,
1132911327 name_val,
......@@ -11334,7 +11332,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1133411332 // is_comptime: bool,
1133511333 Value.makeBool(is_comptime),
1133611334 // alignment: comptime_int,
11337 try Value.Tag.int_u64.create(fields_anon_decl.arena(), alignment),
11335 try field_ty.lazyAbiAlignment(target, fields_anon_decl.arena()),
1133811336 };
1133911337 struct_field_val.* = try Value.Tag.aggregate.create(fields_anon_decl.arena(), struct_field_fields);
1134011338 }
......@@ -22749,11 +22747,9 @@ fn typeAbiSize(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !u64 {
2274922747 return ty.abiSize(target);
2275022748}
2275122749
22752/// TODO merge with Type.abiAlignmentAdvanced
22753fn typeAbiAlignment(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !u32 {
22754 try sema.resolveTypeLayout(block, src, ty);
22750fn typeAbiAlignment(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!u32 {
2275522751 const target = sema.mod.getTarget();
22756 return ty.abiAlignment(target);
22752 return (try ty.abiAlignmentAdvanced(target, .{ .sema_kit = sema.kit(block, src) })).scalar;
2275722753}
2275822754
2275922755/// Not valid to call for packed unions.
src/type.zig+104-81
......@@ -2691,31 +2691,41 @@ pub const Type = extern union {
26912691
26922692 /// Returns 0 for 0-bit types.
26932693 pub fn abiAlignment(ty: Type, target: Target) u32 {
2694 return ty.abiAlignmentAdvanced(target, .eager).scalar;
2694 return (ty.abiAlignmentAdvanced(target, .eager) catch unreachable).scalar;
26952695 }
26962696
26972697 /// May capture a reference to `ty`.
26982698 pub fn lazyAbiAlignment(ty: Type, target: Target, arena: Allocator) !Value {
2699 switch (ty.abiAlignmentAdvanced(target, .{ .lazy = arena })) {
2700 .val => |val| return try val,
2699 switch (try ty.abiAlignmentAdvanced(target, .{ .lazy = arena })) {
2700 .val => |val| return val,
27012701 .scalar => |x| return Value.Tag.int_u64.create(arena, x),
27022702 }
27032703 }
27042704
2705 const AbiAlignmentAdvanced = union(enum) {
2706 scalar: u32,
2707 val: Value,
2708 };
2709
27052710 /// If you pass `eager` you will get back `scalar` and assert the type is resolved.
2711 /// In this case there will be no error, guaranteed.
27062712 /// If you pass `lazy` you may get back `scalar` or `val`.
27072713 /// If `val` is returned, a reference to `ty` has been captured.
2708 fn abiAlignmentAdvanced(
2714 /// If you pass `sema_kit` you will get back `scalar` and resolve the type if
2715 /// necessary, possibly returning a CompileError.
2716 pub fn abiAlignmentAdvanced(
27092717 ty: Type,
27102718 target: Target,
27112719 strat: union(enum) {
27122720 eager,
27132721 lazy: Allocator,
2722 sema_kit: Module.WipAnalysis,
27142723 },
2715 ) union(enum) {
2716 scalar: u32,
2717 val: Allocator.Error!Value,
2718 } {
2724 ) Module.CompileError!AbiAlignmentAdvanced {
2725 const sema_kit = switch (strat) {
2726 .sema_kit => |sk| sk,
2727 else => null,
2728 };
27192729 return switch (ty.tag()) {
27202730 .u1,
27212731 .u8,
......@@ -2735,25 +2745,25 @@ pub const Type = extern union {
27352745 .extern_options,
27362746 .@"opaque",
27372747 .anyopaque,
2738 => return .{ .scalar = 1 },
2748 => return AbiAlignmentAdvanced{ .scalar = 1 },
27392749
27402750 .fn_noreturn_no_args, // represents machine code; not a pointer
27412751 .fn_void_no_args, // represents machine code; not a pointer
27422752 .fn_naked_noreturn_no_args, // represents machine code; not a pointer
27432753 .fn_ccc_void_no_args, // represents machine code; not a pointer
2744 => return .{ .scalar = target_util.defaultFunctionAlignment(target) },
2754 => return AbiAlignmentAdvanced{ .scalar = target_util.defaultFunctionAlignment(target) },
27452755
27462756 // represents machine code; not a pointer
27472757 .function => {
27482758 const alignment = ty.castTag(.function).?.data.alignment;
2749 if (alignment != 0) return .{ .scalar = alignment };
2750 return .{ .scalar = target_util.defaultFunctionAlignment(target) };
2759 if (alignment != 0) return AbiAlignmentAdvanced{ .scalar = alignment };
2760 return AbiAlignmentAdvanced{ .scalar = target_util.defaultFunctionAlignment(target) };
27512761 },
27522762
2753 .i16, .u16 => return .{ .scalar = 2 },
2754 .i32, .u32 => return .{ .scalar = 4 },
2755 .i64, .u64 => return .{ .scalar = 8 },
2756 .u128, .i128 => return .{ .scalar = 16 },
2763 .i16, .u16 => return AbiAlignmentAdvanced{ .scalar = 2 },
2764 .i32, .u32 => return AbiAlignmentAdvanced{ .scalar = 4 },
2765 .i64, .u64 => return AbiAlignmentAdvanced{ .scalar = 8 },
2766 .u128, .i128 => return AbiAlignmentAdvanced{ .scalar = 16 },
27572767
27582768 .isize,
27592769 .usize,
......@@ -2776,40 +2786,40 @@ pub const Type = extern union {
27762786 .manyptr_const_u8_sentinel_0,
27772787 .@"anyframe",
27782788 .anyframe_T,
2779 => return .{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },
2780
2781 .c_short => return .{ .scalar = @divExact(CType.short.sizeInBits(target), 8) },
2782 .c_ushort => return .{ .scalar = @divExact(CType.ushort.sizeInBits(target), 8) },
2783 .c_int => return .{ .scalar = @divExact(CType.int.sizeInBits(target), 8) },
2784 .c_uint => return .{ .scalar = @divExact(CType.uint.sizeInBits(target), 8) },
2785 .c_long => return .{ .scalar = @divExact(CType.long.sizeInBits(target), 8) },
2786 .c_ulong => return .{ .scalar = @divExact(CType.ulong.sizeInBits(target), 8) },
2787 .c_longlong => return .{ .scalar = @divExact(CType.longlong.sizeInBits(target), 8) },
2788 .c_ulonglong => return .{ .scalar = @divExact(CType.ulonglong.sizeInBits(target), 8) },
2789
2790 .f16 => return .{ .scalar = 2 },
2791 .f32 => return .{ .scalar = 4 },
2792 .f64 => return .{ .scalar = 8 },
2793 .f128 => return .{ .scalar = 16 },
2789 => return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },
2790
2791 .c_short => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.short.sizeInBits(target), 8) },
2792 .c_ushort => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ushort.sizeInBits(target), 8) },
2793 .c_int => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.int.sizeInBits(target), 8) },
2794 .c_uint => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.uint.sizeInBits(target), 8) },
2795 .c_long => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.long.sizeInBits(target), 8) },
2796 .c_ulong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulong.sizeInBits(target), 8) },
2797 .c_longlong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.longlong.sizeInBits(target), 8) },
2798 .c_ulonglong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulonglong.sizeInBits(target), 8) },
2799
2800 .f16 => return AbiAlignmentAdvanced{ .scalar = 2 },
2801 .f32 => return AbiAlignmentAdvanced{ .scalar = 4 },
2802 .f64 => return AbiAlignmentAdvanced{ .scalar = 8 },
2803 .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
27942804
27952805 .f80 => switch (target.cpu.arch) {
2796 .i386 => return .{ .scalar = 4 },
2797 .x86_64 => return .{ .scalar = 16 },
2806 .i386 => return AbiAlignmentAdvanced{ .scalar = 4 },
2807 .x86_64 => return AbiAlignmentAdvanced{ .scalar = 16 },
27982808 else => {
27992809 var payload: Payload.Bits = .{
28002810 .base = .{ .tag = .int_unsigned },
28012811 .data = 80,
28022812 };
28032813 const u80_ty = initPayload(&payload.base);
2804 return .{ .scalar = abiAlignment(u80_ty, target) };
2814 return AbiAlignmentAdvanced{ .scalar = abiAlignment(u80_ty, target) };
28052815 },
28062816 },
28072817 .c_longdouble => switch (CType.longdouble.sizeInBits(target)) {
2808 16 => return .{ .scalar = abiAlignment(Type.f16, target) },
2809 32 => return .{ .scalar = abiAlignment(Type.f32, target) },
2810 64 => return .{ .scalar = abiAlignment(Type.f64, target) },
2811 80 => return .{ .scalar = abiAlignment(Type.f80, target) },
2812 128 => return .{ .scalar = abiAlignment(Type.f128, target) },
2818 16 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f16, target) },
2819 32 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f32, target) },
2820 64 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f64, target) },
2821 80 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f80, target) },
2822 128 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f128, target) },
28132823 else => unreachable,
28142824 },
28152825
......@@ -2819,22 +2829,22 @@ pub const Type = extern union {
28192829 .anyerror,
28202830 .error_set_inferred,
28212831 .error_set_merged,
2822 => return .{ .scalar = 2 }, // TODO revisit this when we have the concept of the error tag type
2832 => return AbiAlignmentAdvanced{ .scalar = 2 }, // TODO revisit this when we have the concept of the error tag type
28232833
28242834 .array, .array_sentinel => return ty.elemType().abiAlignmentAdvanced(target, strat),
28252835
28262836 // TODO audit this - is there any more complicated logic to determine
28272837 // ABI alignment of vectors?
2828 .vector => return .{ .scalar = 16 },
2838 .vector => return AbiAlignmentAdvanced{ .scalar = 16 },
28292839
28302840 .int_signed, .int_unsigned => {
28312841 const bits: u16 = ty.cast(Payload.Bits).?.data;
2832 if (bits == 0) return .{ .scalar = 0 };
2833 if (bits <= 8) return .{ .scalar = 1 };
2834 if (bits <= 16) return .{ .scalar = 2 };
2835 if (bits <= 32) return .{ .scalar = 4 };
2836 if (bits <= 64) return .{ .scalar = 8 };
2837 return .{ .scalar = 16 };
2842 if (bits == 0) return AbiAlignmentAdvanced{ .scalar = 0 };
2843 if (bits <= 8) return AbiAlignmentAdvanced{ .scalar = 1 };
2844 if (bits <= 16) return AbiAlignmentAdvanced{ .scalar = 2 };
2845 if (bits <= 32) return AbiAlignmentAdvanced{ .scalar = 4 };
2846 if (bits <= 64) return AbiAlignmentAdvanced{ .scalar = 8 };
2847 return AbiAlignmentAdvanced{ .scalar = 16 };
28382848 },
28392849
28402850 .optional => {
......@@ -2842,17 +2852,19 @@ pub const Type = extern union {
28422852 const child_type = ty.optionalChild(&buf);
28432853
28442854 if (child_type.zigTypeTag() == .Pointer and !child_type.isCPtr()) {
2845 return .{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) };
2855 return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) };
28462856 }
28472857
28482858 switch (strat) {
2849 .eager => {
2850 if (!child_type.hasRuntimeBits()) return .{ .scalar = 1 };
2851 return .{ .scalar = child_type.abiAlignment(target) };
2859 .eager, .sema_kit => {
2860 if (!(try child_type.hasRuntimeBitsAdvanced(false, sema_kit))) {
2861 return AbiAlignmentAdvanced{ .scalar = 1 };
2862 }
2863 return child_type.abiAlignmentAdvanced(target, strat);
28522864 },
2853 .lazy => |arena| switch (child_type.abiAlignmentAdvanced(target, strat)) {
2854 .scalar => |x| return .{ .scalar = @maximum(x, 1) },
2855 .val => return .{ .val = Value.Tag.lazy_align.create(arena, ty) },
2865 .lazy => |arena| switch (try child_type.abiAlignmentAdvanced(target, strat)) {
2866 .scalar => |x| return AbiAlignmentAdvanced{ .scalar = @maximum(x, 1) },
2867 .val => return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
28562868 },
28572869 }
28582870 },
......@@ -2860,60 +2872,64 @@ pub const Type = extern union {
28602872 .error_union => {
28612873 const data = ty.castTag(.error_union).?.data;
28622874 switch (strat) {
2863 .eager => {
2864 if (!data.error_set.hasRuntimeBits()) {
2865 return .{ .scalar = data.payload.abiAlignment(target) };
2866 } else if (!data.payload.hasRuntimeBits()) {
2867 return .{ .scalar = data.error_set.abiAlignment(target) };
2875 .eager, .sema_kit => {
2876 if (!(try data.error_set.hasRuntimeBitsAdvanced(false, sema_kit))) {
2877 return data.payload.abiAlignmentAdvanced(target, strat);
2878 } else if (!(try data.payload.hasRuntimeBitsAdvanced(false, sema_kit))) {
2879 return data.error_set.abiAlignmentAdvanced(target, strat);
28682880 }
2869 return .{ .scalar = @maximum(
2870 data.payload.abiAlignment(target),
2871 data.error_set.abiAlignment(target),
2881 return AbiAlignmentAdvanced{ .scalar = @maximum(
2882 (try data.payload.abiAlignmentAdvanced(target, strat)).scalar,
2883 (try data.error_set.abiAlignmentAdvanced(target, strat)).scalar,
28722884 ) };
28732885 },
28742886 .lazy => |arena| {
2875 switch (data.payload.abiAlignmentAdvanced(target, strat)) {
2887 switch (try data.payload.abiAlignmentAdvanced(target, strat)) {
28762888 .scalar => |payload_align| {
28772889 if (payload_align == 0) {
28782890 return data.error_set.abiAlignmentAdvanced(target, strat);
28792891 }
2880 switch (data.error_set.abiAlignmentAdvanced(target, strat)) {
2892 switch (try data.error_set.abiAlignmentAdvanced(target, strat)) {
28812893 .scalar => |err_set_align| {
2882 return .{ .scalar = @maximum(payload_align, err_set_align) };
2894 return AbiAlignmentAdvanced{ .scalar = @maximum(payload_align, err_set_align) };
28832895 },
28842896 .val => {},
28852897 }
28862898 },
28872899 .val => {},
28882900 }
2889 return .{ .val = Value.Tag.lazy_align.create(arena, ty) };
2901 return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) };
28902902 },
28912903 }
28922904 },
28932905
28942906 .@"struct" => {
2907 if (sema_kit) |sk| {
2908 try sk.sema.resolveTypeLayout(sk.block, sk.src, ty);
2909 }
28952910 if (ty.castTag(.@"struct")) |payload| {
28962911 const struct_obj = payload.data;
28972912 if (!struct_obj.haveLayout()) switch (strat) {
28982913 .eager => unreachable, // struct layout not resolved
2899 .lazy => |arena| return .{ .val = Value.Tag.lazy_align.create(arena, ty) },
2914 .sema_kit => unreachable, // handled above
2915 .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
29002916 };
29012917 if (struct_obj.layout == .Packed) {
29022918 var buf: Type.Payload.Bits = undefined;
29032919 const int_ty = struct_obj.packedIntegerType(target, &buf);
2904 return .{ .scalar = int_ty.abiAlignment(target) };
2920 return AbiAlignmentAdvanced{ .scalar = int_ty.abiAlignment(target) };
29052921 }
29062922 }
29072923
29082924 const fields = ty.structFields();
29092925 var big_align: u32 = 0;
29102926 for (fields.values()) |field| {
2911 if (!field.ty.hasRuntimeBits()) continue;
2927 if (!(try field.ty.hasRuntimeBitsAdvanced(false, sema_kit))) continue;
29122928
29132929 const field_align = field.normalAlignment(target);
29142930 big_align = @maximum(big_align, field_align);
29152931 }
2916 return .{ .scalar = big_align };
2932 return AbiAlignmentAdvanced{ .scalar = big_align };
29172933 },
29182934
29192935 .tuple, .anon_struct => {
......@@ -2923,34 +2939,41 @@ pub const Type = extern union {
29232939 const val = tuple.values[i];
29242940 if (val.tag() != .unreachable_value) continue; // comptime field
29252941
2926 switch (field_ty.abiAlignmentAdvanced(target, strat)) {
2942 switch (try field_ty.abiAlignmentAdvanced(target, strat)) {
29272943 .scalar => |field_align| big_align = @maximum(big_align, field_align),
29282944 .val => switch (strat) {
29292945 .eager => unreachable, // field type alignment not resolved
2930 .lazy => |arena| return .{ .val = Value.Tag.lazy_align.create(arena, ty) },
2946 .sema_kit => unreachable, // passed to abiAlignmentAdvanced above
2947 .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
29312948 },
29322949 }
29332950 }
2934 return .{ .scalar = big_align };
2951 return AbiAlignmentAdvanced{ .scalar = big_align };
29352952 },
29362953
29372954 .enum_full, .enum_nonexhaustive, .enum_simple, .enum_numbered => {
29382955 var buffer: Payload.Bits = undefined;
29392956 const int_tag_ty = ty.intTagType(&buffer);
2940 return .{ .scalar = int_tag_ty.abiAlignment(target) };
2957 return AbiAlignmentAdvanced{ .scalar = int_tag_ty.abiAlignment(target) };
29412958 },
29422959 .@"union" => switch (strat) {
2943 .eager => {
2960 .eager, .sema_kit => {
2961 if (sema_kit) |sk| {
2962 try sk.sema.resolveTypeLayout(sk.block, sk.src, ty);
2963 }
29442964 // TODO pass `true` for have_tag when unions have a safety tag
2945 return .{ .scalar = ty.castTag(.@"union").?.data.abiAlignment(target, false) };
2965 return AbiAlignmentAdvanced{ .scalar = ty.castTag(.@"union").?.data.abiAlignment(target, false) };
29462966 },
2947 .lazy => |arena| return .{ .val = Value.Tag.lazy_align.create(arena, ty) },
2967 .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
29482968 },
29492969 .union_tagged => switch (strat) {
2950 .eager => {
2951 return .{ .scalar = ty.castTag(.union_tagged).?.data.abiAlignment(target, true) };
2970 .eager, .sema_kit => {
2971 if (sema_kit) |sk| {
2972 try sk.sema.resolveTypeLayout(sk.block, sk.src, ty);
2973 }
2974 return AbiAlignmentAdvanced{ .scalar = ty.castTag(.union_tagged).?.data.abiAlignment(target, true) };
29522975 },
2953 .lazy => |arena| return .{ .val = Value.Tag.lazy_align.create(arena, ty) },
2976 .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
29542977 },
29552978
29562979 .empty_struct,
......@@ -2963,7 +2986,7 @@ pub const Type = extern union {
29632986 .@"undefined",
29642987 .enum_literal,
29652988 .type_info,
2966 => return .{ .scalar = 0 },
2989 => return AbiAlignmentAdvanced{ .scalar = 0 },
29672990
29682991 .noreturn,
29692992 .inferred_alloc_const,
src/value.zig+3-2
......@@ -1076,9 +1076,10 @@ pub const Value = extern union {
10761076 .lazy_align => {
10771077 const ty = val.castTag(.lazy_align).?.data;
10781078 if (sema_kit) |sk| {
1079 try sk.sema.resolveTypeLayout(sk.block, sk.src, ty);
1079 return (try ty.abiAlignmentAdvanced(target, .{ .sema_kit = sk })).scalar;
1080 } else {
1081 return ty.abiAlignment(target);
10801082 }
1081 return ty.abiAlignment(target);
10821083 },
10831084
10841085 else => return null,