Commit a51c76541d60da81ef53e0ab1f221a80d9956bd5 | zig

src/Sema.zig+26-31

src/codegen/llvm.zig+183-164

 @@ -10396,12 +10396,7 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool
             .mips, .mipsel => return false,
             .x86_64 => switch (target.os.tag) {
                 .windows => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory,
-                else => {
+                else => return firstParamSRetSystemV(fn_info.return_type, target),
-                    const class = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret);
-                    if (class[0] == .memory) return true;
-                    if (class[0] == .x87 and class[2] != .none) return true;
-                    return false;
-                },
             },
             .wasm32 => return wasm_c_abi.classifyType(fn_info.return_type, target)[0] == .indirect,
             .aarch64, .aarch64_be => return aarch64_c_abi.classifyType(fn_info.return_type, target) == .memory,
 @@ -10413,11 +10408,20 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool
             .riscv32, .riscv64 => return riscv_c_abi.classifyType(fn_info.return_type, target) == .memory,
             else => return false, // TODO investigate C ABI for other architectures
         },
+        .SysV => return firstParamSRetSystemV(fn_info.return_type, target),
+        .Win64 => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory,
         .Stdcall => return !isScalar(fn_info.return_type),
         else => return false,
     }
 }
+fn firstParamSRetSystemV(ty: Type, target: std.Target) bool {
+    const class = x86_64_abi.classifySystemV(ty, target, .ret);
+    if (class[0] == .memory) return true;
+    if (class[0] == .x87 and class[2] != .none) return true;
+    return false;
+}
 /// In order to support the C calling convention, some return types need to be lowered
 /// completely differently in the function prototype to honor the C ABI, and then
 /// be effectively bitcasted to the actual return type.
 @@ -10442,77 +10446,14 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
             }
         },
         .C => {
-            const is_scalar = isScalar(fn_info.return_type);
             switch (target.cpu.arch) {
                 .mips, .mipsel => return dg.lowerType(fn_info.return_type),
                 .x86_64 => switch (target.os.tag) {
-                    .windows => switch (x86_64_abi.classifyWindows(fn_info.return_type, target)) {
+                    .windows => return lowerWin64FnRetTy(dg, fn_info),
-                        .integer => {
+                    else => return lowerSystemVFnRetTy(dg, fn_info),
-                            if (is_scalar) {
-                                return dg.lowerType(fn_info.return_type);
-                            } else {
-                                const abi_size = fn_info.return_type.abiSize(target);
-                                return dg.context.intType(@intCast(c_uint, abi_size * 8));
-                            }
-                        },
-                        .win_i128 => return dg.context.intType(64).vectorType(2),
-                        .memory => return dg.context.voidType(),
-                        .sse => return dg.lowerType(fn_info.return_type),
-                        else => unreachable,
-                    },
-                    else => {
-                        if (is_scalar) {
-                            return dg.lowerType(fn_info.return_type);
-                        }
-                        const classes = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret);
-                        if (classes[0] == .memory) {
-                            return dg.context.voidType();
-                        }
-                        var llvm_types_buffer: [8]*llvm.Type = undefined;
-                        var llvm_types_index: u32 = 0;
-                        for (classes) |class| {
-                            switch (class) {
-                                .integer => {
-                                    llvm_types_buffer[llvm_types_index] = dg.context.intType(64);
-                                    llvm_types_index += 1;
-                                },
-                                .sse, .sseup => {
-                                    llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
-                                    llvm_types_index += 1;
-                                },
-                                .float => {
-                                    llvm_types_buffer[llvm_types_index] = dg.context.floatType();
-                                    llvm_types_index += 1;
-                                },
-                                .float_combine => {
-                                    llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2);
-                                    llvm_types_index += 1;
-                                },
-                                .x87 => {
-                                    if (llvm_types_index != 0 or classes[2] != .none) {
-                                        return dg.context.voidType();
-                                    }
-                                    llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
-                                    llvm_types_index += 1;
-                                },
-                                .x87up => continue,
-                                .complex_x87 => {
-                                    @panic("TODO");
-                                },
-                                .memory => unreachable, // handled above
-                                .win_i128 => unreachable, // windows only
-                                .none => break,
-                            }
-                        }
-                        if (classes[0] == .integer and classes[1] == .none) {
-                            const abi_size = fn_info.return_type.abiSize(target);
-                            return dg.context.intType(@intCast(c_uint, abi_size * 8));
-                        }
-                        return dg.context.structType(&llvm_types_buffer, llvm_types_index, .False);
-                    },
                 },
                 .wasm32 => {
-                    if (is_scalar) {
+                    if (isScalar(fn_info.return_type)) {
                         return dg.lowerType(fn_info.return_type);
                     }
                     const classes = wasm_c_abi.classifyType(fn_info.return_type, target);
 @@ -10569,6 +10510,8 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
                 else => return dg.lowerType(fn_info.return_type),
             }
         },
+        .Win64 => return lowerWin64FnRetTy(dg, fn_info),
+        .SysV => return lowerSystemVFnRetTy(dg, fn_info),
         .Stdcall => {
             if (isScalar(fn_info.return_type)) {
                 return dg.lowerType(fn_info.return_type);
 @@ -10580,6 +10523,76 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
     }
 }
+fn lowerWin64FnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
+    const target = dg.module.getTarget();
+    switch (x86_64_abi.classifyWindows(fn_info.return_type, target)) {
+        .integer => {
+            if (isScalar(fn_info.return_type)) {
+                return dg.lowerType(fn_info.return_type);
+            } else {
+                const abi_size = fn_info.return_type.abiSize(target);
+                return dg.context.intType(@intCast(c_uint, abi_size * 8));
+            }
+        },
+        .win_i128 => return dg.context.intType(64).vectorType(2),
+        .memory => return dg.context.voidType(),
+        .sse => return dg.lowerType(fn_info.return_type),
+        else => unreachable,
+    }
+}
+fn lowerSystemVFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
+    if (isScalar(fn_info.return_type)) {
+        return dg.lowerType(fn_info.return_type);
+    }
+    const target = dg.module.getTarget();
+    const classes = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret);
+    if (classes[0] == .memory) {
+        return dg.context.voidType();
+    }
+    var llvm_types_buffer: [8]*llvm.Type = undefined;
+    var llvm_types_index: u32 = 0;
+    for (classes) |class| {
+        switch (class) {
+            .integer => {
+                llvm_types_buffer[llvm_types_index] = dg.context.intType(64);
+                llvm_types_index += 1;
+            },
+            .sse, .sseup => {
+                llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
+                llvm_types_index += 1;
+            },
+            .float => {
+                llvm_types_buffer[llvm_types_index] = dg.context.floatType();
+                llvm_types_index += 1;
+            },
+            .float_combine => {
+                llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2);
+                llvm_types_index += 1;
+            },
+            .x87 => {
+                if (llvm_types_index != 0 or classes[2] != .none) {
+                    return dg.context.voidType();
+                }
+                llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
+                llvm_types_index += 1;
+            },
+            .x87up => continue,
+            .complex_x87 => {
+                @panic("TODO");
+            },
+            .memory => unreachable, // handled above
+            .win_i128 => unreachable, // windows only
+            .none => break,
+        }
+    }
+    if (classes[0] == .integer and classes[1] == .none) {
+        const abi_size = fn_info.return_type.abiSize(target);
+        return dg.context.intType(@intCast(c_uint, abi_size * 8));
+    }
+    return dg.context.structType(&llvm_types_buffer, llvm_types_index, .False);
+}
 const ParamTypeIterator = struct {
     dg: *DeclGen,
     fn_info: Type.Payload.Function.Data,
 @@ -10629,7 +10642,6 @@ const ParamTypeIterator = struct {
             it.zig_index += 1;
             return .no_bits;
         }
-        const dg = it.dg;
         switch (it.fn_info.cc) {
             .Unspecified, .Inline => {
                 it.zig_index += 1;
 @@ -10648,7 +10660,6 @@ const ParamTypeIterator = struct {
                 @panic("TODO implement async function lowering in the LLVM backend");
             },
             .C => {
-                const is_scalar = isScalar(ty);
                 switch (it.target.cpu.arch) {
                     .mips, .mipsel => {
                         it.zig_index += 1;
 @@ -10656,99 +10667,13 @@ const ParamTypeIterator = struct {
                         return .byval;
                     },
                     .x86_64 => switch (it.target.os.tag) {
-                        .windows => switch (x86_64_abi.classifyWindows(ty, it.target)) {
+                        .windows => return it.nextWin64(ty),
-                            .integer => {
+                        else => return it.nextSystemV(ty),
-                                if (is_scalar) {
-                                    it.zig_index += 1;
-                                    it.llvm_index += 1;
-                                    return .byval;
-                                } else {
-                                    it.zig_index += 1;
-                                    it.llvm_index += 1;
-                                    return .abi_sized_int;
-                                }
-                            },
-                            .win_i128 => {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                return .byref;
-                            },
-                            .memory => {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                return .byref_mut;
-                            },
-                            .sse => {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                return .byval;
-                            },
-                            else => unreachable,
-                        },
-                        else => {
-                            const classes = x86_64_abi.classifySystemV(ty, it.target, .arg);
-                            if (classes[0] == .memory) {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                it.byval_attr = true;
-                                return .byref;
-                            }
-                            if (is_scalar) {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                return .byval;
-                            }
-                            var llvm_types_buffer: [8]*llvm.Type = undefined;
-                            var llvm_types_index: u32 = 0;
-                            for (classes) |class| {
-                                switch (class) {
-                                    .integer => {
-                                        llvm_types_buffer[llvm_types_index] = dg.context.intType(64);
-                                        llvm_types_index += 1;
-                                    },
-                                    .sse, .sseup => {
-                                        llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
-                                        llvm_types_index += 1;
-                                    },
-                                    .float => {
-                                        llvm_types_buffer[llvm_types_index] = dg.context.floatType();
-                                        llvm_types_index += 1;
-                                    },
-                                    .float_combine => {
-                                        llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2);
-                                        llvm_types_index += 1;
-                                    },
-                                    .x87 => {
-                                        it.zig_index += 1;
-                                        it.llvm_index += 1;
-                                        it.byval_attr = true;
-                                        return .byref;
-                                    },
-                                    .x87up => unreachable,
-                                    .complex_x87 => {
-                                        @panic("TODO");
-                                    },
-                                    .memory => unreachable, // handled above
-                                    .win_i128 => unreachable, // windows only
-                                    .none => break,
-                                }
-                            }
-                            if (classes[0] == .integer and classes[1] == .none) {
-                                it.zig_index += 1;
-                                it.llvm_index += 1;
-                                return .abi_sized_int;
-                            }
-                            it.llvm_types_buffer = llvm_types_buffer;
-                            it.llvm_types_len = llvm_types_index;
-                            it.llvm_index += llvm_types_index;
-                            it.zig_index += 1;
-                            return .multiple_llvm_types;
-                        },
                     },
                     .wasm32 => {
                         it.zig_index += 1;
                         it.llvm_index += 1;
-                        if (is_scalar) {
+                        if (isScalar(ty)) {
                             return .byval;
                         }
                         const classes = wasm_c_abi.classifyType(ty, it.target);
 @@ -10766,7 +10691,7 @@ const ParamTypeIterator = struct {
                             .byval => return .byval,
                             .integer => {
                                 it.llvm_types_len = 1;
-                                it.llvm_types_buffer[0] = dg.context.intType(64);
+                                it.llvm_types_buffer[0] = it.dg.context.intType(64);
                                 return .multiple_llvm_types;
                             },
                             .double_integer => return Lowering{ .i64_array = 2 },
 @@ -10806,6 +10731,8 @@ const ParamTypeIterator = struct {
                     },
                 }
             },
+            .Win64 => return it.nextWin64(ty),
+            .SysV => return it.nextSystemV(ty),
             .Stdcall => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
 @@ -10824,6 +10751,98 @@ const ParamTypeIterator = struct {
             },
         }
     }
+    fn nextWin64(it: *ParamTypeIterator, ty: Type) ?Lowering {
+        switch (x86_64_abi.classifyWindows(ty, it.target)) {
+            .integer => {
+                if (isScalar(ty)) {
+                    it.zig_index += 1;
+                    it.llvm_index += 1;
+                    return .byval;
+                } else {
+                    it.zig_index += 1;
+                    it.llvm_index += 1;
+                    return .abi_sized_int;
+                }
+            },
+            .win_i128 => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                return .byref;
+            },
+            .memory => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                return .byref_mut;
+            },
+            .sse => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                return .byval;
+            },
+            else => unreachable,
+        }
+    }
+    fn nextSystemV(it: *ParamTypeIterator, ty: Type) ?Lowering {
+        const classes = x86_64_abi.classifySystemV(ty, it.target, .arg);
+        if (classes[0] == .memory) {
+            it.zig_index += 1;
+            it.llvm_index += 1;
+            it.byval_attr = true;
+            return .byref;
+        }
+        if (isScalar(ty)) {
+            it.zig_index += 1;
+            it.llvm_index += 1;
+            return .byval;
+        }
+        var llvm_types_buffer: [8]*llvm.Type = undefined;
+        var llvm_types_index: u32 = 0;
+        for (classes) |class| {
+            switch (class) {
+                .integer => {
+                    llvm_types_buffer[llvm_types_index] = it.dg.context.intType(64);
+                    llvm_types_index += 1;
+                },
+                .sse, .sseup => {
+                    llvm_types_buffer[llvm_types_index] = it.dg.context.doubleType();
+                    llvm_types_index += 1;
+                },
+                .float => {
+                    llvm_types_buffer[llvm_types_index] = it.dg.context.floatType();
+                    llvm_types_index += 1;
+                },
+                .float_combine => {
+                    llvm_types_buffer[llvm_types_index] = it.dg.context.floatType().vectorType(2);
+                    llvm_types_index += 1;
+                },
+                .x87 => {
+                    it.zig_index += 1;
+                    it.llvm_index += 1;
+                    it.byval_attr = true;
+                    return .byref;
+                },
+                .x87up => unreachable,
+                .complex_x87 => {
+                    @panic("TODO");
+                },
+                .memory => unreachable, // handled above
+                .win_i128 => unreachable, // windows only
+                .none => break,
+            }
+        }
+        if (classes[0] == .integer and classes[1] == .none) {
+            it.zig_index += 1;
+            it.llvm_index += 1;
+            return .abi_sized_int;
+        }
+        it.llvm_types_buffer = llvm_types_buffer;
+        it.llvm_types_len = llvm_types_index;
+        it.llvm_index += llvm_types_index;
+        it.zig_index += 1;
+        return .multiple_llvm_types;
+    }
 };
 fn iterateParamTypes(dg: *DeclGen, fn_info: Type.Payload.Function.Data) ParamTypeIterator {

src/type.zig+37-9

 @@ -3789,6 +3789,39 @@ pub const Type = extern union {
         }
     }
+    /// Returns true if the type's layout is already resolved and it is safe
+    /// to use `abiSize`, `abiAlignment` and `bitSize` on it.
+    pub fn layoutIsResolved(ty: Type) bool {
+        switch (ty.zigTypeTag()) {
+            .Struct => {
+                if (ty.castTag(.@"struct")) |struct_ty| {
+                    return struct_ty.data.haveLayout();
+                }
+                return true;
+            },
+            .Union => {
+                if (ty.cast(Payload.Union)) |union_ty| {
+                    return union_ty.data.haveLayout();
+                }
+                return true;
+            },
+            .Array => {
+                if (ty.arrayLenIncludingSentinel() == 0) return true;
+                return ty.childType().layoutIsResolved();
+            },
+            .Optional => {
+                var buf: Type.Payload.ElemType = undefined;
+                const payload_ty = ty.optionalChild(&buf);
+                return payload_ty.layoutIsResolved();
+            },
+            .ErrorUnion => {
+                const payload_ty = ty.errorUnionPayload();
+                return payload_ty.layoutIsResolved();
+            },
+            else => return true,
+        }
+    }
     pub fn isSinglePointer(self: Type) bool {
         return switch (self.tag()) {
             .single_const_pointer,
 @@ -5500,7 +5533,7 @@ pub const Type = extern union {
         }
         const S = struct {
             fn fieldWithRange(int_ty: Type, int_val: Value, end: usize, m: *Module) ?usize {
-                if (int_val.compareAllWithZero(.lt)) return null;
+                if (int_val.compareAllWithZero(.lt, m)) return null;
                 var end_payload: Value.Payload.U64 = .{
                     .base = .{ .tag = .int_u64 },
                     .data = end,
 @@ -6498,12 +6531,7 @@ pub const Type = extern union {
         // pointee type needs to be resolved more, that needs to be done before calling
         // this ptr() function.
         if (d.@"align" != 0) canonicalize: {
-            if (d.pointee_type.castTag(.@"struct")) |struct_ty| {
+            if (!d.pointee_type.layoutIsResolved()) break :canonicalize;
-                if (!struct_ty.data.haveLayout()) break :canonicalize;
-            }
-            if (d.pointee_type.cast(Payload.Union)) |union_ty| {
-                if (!union_ty.data.haveLayout()) break :canonicalize;
-            }
             if (d.@"align" == d.pointee_type.abiAlignment(target)) {
                 d.@"align" = 0;
             }
 @@ -6528,12 +6556,12 @@ pub const Type = extern union {
                 if (!d.mutable and d.pointee_type.eql(Type.u8, mod)) {
                     switch (d.size) {
                         .Slice => {
-                            if (sent.compareAllWithZero(.eq)) {
+                            if (sent.compareAllWithZero(.eq, mod)) {
                                 return Type.initTag(.const_slice_u8_sentinel_0);
                             }
                         },
                         .Many => {
-                            if (sent.compareAllWithZero(.eq)) {
+                            if (sent.compareAllWithZero(.eq, mod)) {
                                 return Type.initTag(.manyptr_const_u8_sentinel_0);
                             }
                         },

src/value.zig+29-5

 @@ -2076,13 +2076,22 @@ pub const Value = extern union {
     /// For vectors, returns true if comparison is true for ALL elements.
     ///
     /// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)`
-    pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator) bool {
+    pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, mod: *Module) bool {
-        return compareAllWithZeroAdvanced(lhs, op, null) catch unreachable;
+        return compareAllWithZeroAdvancedExtra(lhs, op, mod, null) catch unreachable;
     }
     pub fn compareAllWithZeroAdvanced(
         lhs: Value,
         op: std.math.CompareOperator,
+        sema: *Sema,
+    ) Module.CompileError!bool {
+        return compareAllWithZeroAdvancedExtra(lhs, op, sema.mod, sema);
+    }
+    pub fn compareAllWithZeroAdvancedExtra(
+        lhs: Value,
+        op: std.math.CompareOperator,
+        mod: *Module,
         opt_sema: ?*Sema,
     ) Module.CompileError!bool {
         if (lhs.isInf()) {
 @@ -2095,10 +2104,25 @@ pub const Value = extern union {
         }
         switch (lhs.tag()) {
-            .repeated => return lhs.castTag(.repeated).?.data.compareAllWithZeroAdvanced(op, opt_sema),
+            .repeated => return lhs.castTag(.repeated).?.data.compareAllWithZeroAdvancedExtra(op, mod, opt_sema),
             .aggregate => {
                 for (lhs.castTag(.aggregate).?.data) |elem_val| {
-                    if (!(try elem_val.compareAllWithZeroAdvanced(op, opt_sema))) return false;
+                    if (!(try elem_val.compareAllWithZeroAdvancedExtra(op, mod, opt_sema))) return false;
+                }
+                return true;
+            },
+            .str_lit => {
+                const str_lit = lhs.castTag(.str_lit).?.data;
+                const bytes = mod.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
+                for (bytes) |byte| {
+                    if (!std.math.compare(byte, op, 0)) return false;
+                }
+                return true;
+            },
+            .bytes => {
+                const bytes = lhs.castTag(.bytes).?.data;
+                for (bytes) |byte| {
+                    if (!std.math.compare(byte, op, 0)) return false;
                 }
                 return true;
             },
 @@ -3103,7 +3127,7 @@ pub const Value = extern union {
             .int_i64,
             .int_big_positive,
             .int_big_negative,
-            => compareAllWithZero(self, .eq),
+            => self.orderAgainstZero().compare(.eq),
             .undef => unreachable,
             .unreachable_value => unreachable,

test/behavior.zig-1

...	@@ -106,7 +106,6 @@ test {	...	@@ -106,7 +106,6 @@ test {
106	_ = @import("behavior/bugs/12430.zig");	106	_ = @import("behavior/bugs/12430.zig");
107	_ = @import("behavior/bugs/12450.zig");	107	_ = @import("behavior/bugs/12450.zig");
108	_ = @import("behavior/bugs/12486.zig");	108	_ = @import("behavior/bugs/12486.zig");
109	_ = @import("behavior/bugs/12488.zig");
110	_ = @import("behavior/bugs/12498.zig");	109	_ = @import("behavior/bugs/12498.zig");
111	_ = @import("behavior/bugs/12551.zig");	110	_ = @import("behavior/bugs/12551.zig");
112	_ = @import("behavior/bugs/12571.zig");	111	_ = @import("behavior/bugs/12571.zig");

test/behavior/bugs/12488.zig deleted-13

...	@@ -1,13 +0,0 @@
1	const expect = @import("std").testing.expect;
2
3	const A = struct {
4	a: u32,
5	};
6
7	fn foo(comptime a: anytype) !void {
8	try expect(a[0][0] == @sizeOf(A));
9	}
10
11	test {
12	try foo(.{[_]usize{@sizeOf(A)}});
13	}

test/behavior/fn.zig+23

...	@@ -517,3 +517,26 @@ test "peer type resolution of inferred error set with non-void payload" {	...	@@ -517,3 +517,26 @@ test "peer type resolution of inferred error set with non-void payload" {
517	};	517	};
518	try expect(try S.openDataFile(.read) == 1);	518	try expect(try S.openDataFile(.read) == 1);
519	}	519	}
		520
		521	test "lazy values passed to anytype parameter" {
		522	const A = struct {
		523	a: u32,
		524	fn foo(comptime a: anytype) !void {
		525	try expect(a[0][0] == @sizeOf(@This()));
		526	}
		527	};
		528	try A.foo(.{[_]usize{@sizeOf(A)}});
		529
		530	const B = struct {
		531	fn foo(comptime a: anytype) !void {
		532	try expect(a.x == 0);
		533	}
		534	};
		535	try B.foo(.{ .x = @sizeOf(B) });
		536
		537	const C = struct {};
		538	try expect(@truncate(u32, @sizeOf(C)) == 0);
		539
		540	const D = struct {};
		541	try expect(@sizeOf(D) << 1 == 0);
		542	}

test/behavior/pointers.zig+15

...	@@ -532,3 +532,18 @@ test "pointer alignment and element type include call expression" {	...	@@ -532,3 +532,18 @@ test "pointer alignment and element type include call expression" {
532	};	532	};
533	try expect(@alignOf(S.P) > 0);	533	try expect(@alignOf(S.P) > 0);
534	}	534	}
		535
		536	test "pointer to array has explicit alignment" {
		537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		538
		539	const S = struct {
		540	const Base = extern struct { a: u8 };
		541	const Base2 = extern struct { a: u8 };
		542	fn func(ptr: [4]Base) align(1) [4]Base2 {
		543	return @alignCast(1, @ptrCast(*[4]Base2, ptr));
		544	}
		545	};
		546	var bases = [_]S.Base{.{ .a = 2 }} ** 4;
		547	const casted = S.func(&bases);
		548	try expect(casted[0].a == 2);
		549	}

test/behavior/struct.zig+5

...	@@ -1573,3 +1573,8 @@ test "struct fields get automatically reordered" {	...	@@ -1573,3 +1573,8 @@ test "struct fields get automatically reordered" {
1573	};	1573	};
1574	try expect(@sizeOf(S1) == @sizeOf(S2));	1574	try expect(@sizeOf(S1) == @sizeOf(S2));
1575	}	1575	}
		1576
		1577	test "directly initiating tuple like struct" {
		1578	const a = struct { u8 }{8};
		1579	try expect(a[0] == 8);
		1580	}

test/behavior/vector.zig+11

...	@@ -1286,3 +1286,14 @@ test "store to vector in slice" {	...	@@ -1286,3 +1286,14 @@ test "store to vector in slice" {
1286	s[i] = s[0];	1286	s[i] = s[0];
1287	try expectEqual(v[1], v[0]);	1287	try expectEqual(v[1], v[0]);
1288	}	1288	}
		1289
		1290	test "addition of vectors represented as strings" {
		1291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		1292	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1293	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		1294
		1295	const V = @Vector(3, u8);
		1296	const foo: V = "foo".*;
		1297	const bar: V = @typeName(u32).*;
		1298	try expectEqual(V{ 219, 162, 161 }, foo + bar);
		1299	}

test/c_abi/cfuncs.c+12

...	@@ -1015,3 +1015,15 @@ void __attribute__((stdcall)) stdcall_big_union(union BigUnion x) {	...	@@ -1015,3 +1015,15 @@ void __attribute__((stdcall)) stdcall_big_union(union BigUnion x) {
1015	assert_or_panic(x.a.c == 3);	1015	assert_or_panic(x.a.c == 3);
1016	assert_or_panic(x.a.d == 4);	1016	assert_or_panic(x.a.d == 4);
1017	}	1017	}
		1018
		1019	#ifdef __x86_64__
		1020	struct ByRef __attribute__((ms_abi)) c_explict_win64(struct ByRef in) {
		1021	in.val = 42;
		1022	return in;
		1023	}
		1024
		1025	struct ByRef __attribute__((sysv_abi)) c_explict_sys_v(struct ByRef in) {
		1026	in.val = 42;
		1027	return in;
		1028	}
		1029	#endif

test/c_abi/main.zig+16

...	@@ -1190,3 +1190,19 @@ test "Stdcall ABI big union" {	...	@@ -1190,3 +1190,19 @@ test "Stdcall ABI big union" {
1190	};	1190	};
1191	stdcall_big_union(x);	1191	stdcall_big_union(x);
1192	}	1192	}
		1193
		1194	extern fn c_explict_win64(ByRef) callconv(.Win64) ByRef;
		1195	test "explicit SysV calling convention" {
		1196	if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
		1197
		1198	const res = c_explict_win64(.{ .val = 1, .arr = undefined });
		1199	try expect(res.val == 42);
		1200	}
		1201
		1202	extern fn c_explict_sys_v(ByRef) callconv(.SysV) ByRef;
		1203	test "explicit Win64 calling convention" {
		1204	if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
		1205
		1206	const res = c_explict_sys_v(.{ .val = 1, .arr = undefined });
		1207	try expect(res.val == 42);
		1208	}

test/cases/compile_errors/bad_member_access_on_tuple.zig created+9

...	@@ -0,0 +1,9 @@
1	comptime {
2	_ = @TypeOf(.{}).is_optional;
3	}
4
5	// error
6	// backend=stage2
7	// target=native
8	//
9	// :2:21: error: struct '@TypeOf(.{})' has no member named 'is_optional'

author	Andrew Kelley <andrew@ziglang.org> 2023-01-22 00:36:50-05:00
committer	GitHub <noreply@github.com> 2023-01-22 00:36:50-05:00
log	a51c76541d60da81ef53e0ab1f221a80d9956bd5
tree	023a1f1fbc02b646214b70d78dad0acb7ec158f3
parent	f85c01d4c7520d2242626f4c0684ab97e47af373
parent	aa626deadddcf26a5789d29d5ba88c978ee53b89
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -3948,6 +3948,7 @@ fn validateArrayInitTy(	...	@@ -3948,6 +3948,7 @@ fn validateArrayInitTy(
3948	return;	3948	return;
3949	},	3949	},
3950	.Struct => if (ty.isTuple()) {	3950	.Struct => if (ty.isTuple()) {
		3951	_ = try sema.resolveTypeFields(ty);
3951	const array_len = ty.arrayLen();	3952	const array_len = ty.arrayLen();
3952	if (extra.init_count > array_len) {	3953	if (extra.init_count > array_len) {
3953	return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{	3954	return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
...	@@ -4642,11 +4643,11 @@ fn failWithBadMemberAccess(	...	@@ -4642,11 +4643,11 @@ fn failWithBadMemberAccess(
4642	.Enum => "enum",	4643	.Enum => "enum",
4643	else => unreachable,	4644	else => unreachable,
4644	};	4645	};
4645	if (sema.mod.declIsRoot(agg_ty.getOwnerDecl())) {	4646	if (agg_ty.getOwnerDeclOrNull()) \|some\| if (sema.mod.declIsRoot(some)) {
4646	return sema.fail(block, field_src, "root struct of file '{}' has no member named '{s}'", .{	4647	return sema.fail(block, field_src, "root struct of file '{}' has no member named '{s}'", .{
4647	agg_ty.fmt(sema.mod), field_name,	4648	agg_ty.fmt(sema.mod), field_name,
4648	});	4649	});
4649	}	4650	};
4650	const msg = msg: {	4651	const msg = msg: {
4651	const msg = try sema.errMsg(block, field_src, "{s} '{}' has no member named '{s}'", .{	4652	const msg = try sema.errMsg(block, field_src, "{s} '{}' has no member named '{s}'", .{
4652	kw_name, agg_ty.fmt(sema.mod), field_name,	4653	kw_name, agg_ty.fmt(sema.mod), field_name,
...	@@ -7514,7 +7515,7 @@ fn resolveGenericInstantiationType(	...	@@ -7514,7 +7515,7 @@ fn resolveGenericInstantiationType(
7514	}	7515	}
7515		7516
7516	fn resolveTupleLazyValues(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) CompileError!void {	7517	fn resolveTupleLazyValues(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) CompileError!void {
7517	if (!ty.isSimpleTuple()) return;	7518	if (!ty.isSimpleTupleOrAnonStruct()) return;
7518	const tuple = ty.tupleFields();	7519	const tuple = ty.tupleFields();
7519	for (tuple.values) \|field_val, i\| {	7520	for (tuple.values) \|field_val, i\| {
7520	try sema.resolveTupleLazyValues(block, src, tuple.types[i]);	7521	try sema.resolveTupleLazyValues(block, src, tuple.types[i]);
...	@@ -11771,8 +11772,8 @@ fn zirShl(	...	@@ -11771,8 +11772,8 @@ fn zirShl(
11771	// TODO coerce rhs if air_tag is not shl_sat	11772	// TODO coerce rhs if air_tag is not shl_sat
11772	const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);	11773	const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
11773		11774
11774	const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs);	11775	const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);
11775	const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs);	11776	const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);
11776		11777
11777	if (maybe_rhs_val) \|rhs_val\| {	11778	if (maybe_rhs_val) \|rhs_val\| {
11778	if (rhs_val.isUndef()) {	11779	if (rhs_val.isUndef()) {
...	@@ -11842,7 +11843,7 @@ fn zirShl(	...	@@ -11842,7 +11843,7 @@ fn zirShl(
11842	if (scalar_ty.zigTypeTag() == .ComptimeInt) {	11843	if (scalar_ty.zigTypeTag() == .ComptimeInt) {
11843	break :val shifted.wrapped_result;	11844	break :val shifted.wrapped_result;
11844	}	11845	}
11845	if (shifted.overflow_bit.compareAllWithZero(.eq)) {	11846	if (shifted.overflow_bit.compareAllWithZero(.eq, sema.mod)) {
11846	break :val shifted.wrapped_result;	11847	break :val shifted.wrapped_result;
11847	}	11848	}
11848	return sema.fail(block, src, "operation caused overflow", .{});	11849	return sema.fail(block, src, "operation caused overflow", .{});
...	@@ -11959,8 +11960,8 @@ fn zirShr(	...	@@ -11959,8 +11960,8 @@ fn zirShr(
11959	const target = sema.mod.getTarget();	11960	const target = sema.mod.getTarget();
11960	const scalar_ty = lhs_ty.scalarType();	11961	const scalar_ty = lhs_ty.scalarType();
11961		11962
11962	const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs);	11963	const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);
11963	const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs);	11964	const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);
11964		11965
11965	const runtime_src = if (maybe_rhs_val) \|rhs_val\| rs: {	11966	const runtime_src = if (maybe_rhs_val) \|rhs_val\| rs: {
11966	if (rhs_val.isUndef()) {	11967	if (rhs_val.isUndef()) {
...	@@ -12799,7 +12800,7 @@ fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -12799,7 +12800,7 @@ fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
12799	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	12800	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
12800	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	12801	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
12801	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	12802	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
12802	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div);	12803	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
12803		12804
12804	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	12805	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
12805	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	12806	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -12831,7 +12832,7 @@ fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -12831,7 +12832,7 @@ fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
12831	const lhs_val = maybe_lhs_val orelse unreachable;	12832	const lhs_val = maybe_lhs_val orelse unreachable;
12832	const rhs_val = maybe_rhs_val orelse unreachable;	12833	const rhs_val = maybe_rhs_val orelse unreachable;
12833	const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod) catch unreachable;	12834	const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod) catch unreachable;
12834	if (!rem.compareAllWithZero(.eq)) {	12835	if (!rem.compareAllWithZero(.eq, mod)) {
12835	return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{	12836	return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{
12836	@tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),	12837	@tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),
12837	});	12838	});
...	@@ -12959,7 +12960,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -12959,7 +12960,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
12959	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	12960	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
12960	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	12961	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
12961	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	12962	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
12962	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_exact);	12963	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
12963		12964
12964	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	12965	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
12965	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	12966	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -13024,7 +13025,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -13024,7 +13025,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
13024	if (maybe_rhs_val) \|rhs_val\| {	13025	if (maybe_rhs_val) \|rhs_val\| {
13025	if (is_int) {	13026	if (is_int) {
13026	const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod);	13027	const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod);
13027	if (!(modulus_val.compareAllWithZero(.eq))) {	13028	if (!(modulus_val.compareAllWithZero(.eq, mod))) {
13028	return sema.fail(block, src, "exact division produced remainder", .{});	13029	return sema.fail(block, src, "exact division produced remainder", .{});
13029	}	13030	}
13030	const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, mod);	13031	const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, mod);
...	@@ -13035,7 +13036,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -13035,7 +13036,7 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
13035	return sema.addConstant(resolved_type, res);	13036	return sema.addConstant(resolved_type, res);
13036	} else {	13037	} else {
13037	const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod);	13038	const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod);
13038	if (!(modulus_val.compareAllWithZero(.eq))) {	13039	if (!(modulus_val.compareAllWithZero(.eq, mod))) {
13039	return sema.fail(block, src, "exact division produced remainder", .{});	13040	return sema.fail(block, src, "exact division produced remainder", .{});
13040	}	13041	}
13041	return sema.addConstant(	13042	return sema.addConstant(
...	@@ -13122,7 +13123,7 @@ fn zirDivFloor(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -13122,7 +13123,7 @@ fn zirDivFloor(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
13122	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	13123	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
13123	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	13124	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
13124	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	13125	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13125	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_floor);	13126	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
13126		13127
13127	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	13128	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
13128	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	13129	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -13238,7 +13239,7 @@ fn zirDivTrunc(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -13238,7 +13239,7 @@ fn zirDivTrunc(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
13238	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	13239	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
13239	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	13240	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
13240	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	13241	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13241	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_trunc);	13242	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
13242		13243
13243	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	13244	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
13244	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	13245	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -13481,7 +13482,7 @@ fn zirModRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.	...	@@ -13481,7 +13482,7 @@ fn zirModRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.
13481	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	13482	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
13482	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	13483	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
13483	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	13484	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13484	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod_rem);	13485	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
13485		13486
13486	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	13487	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
13487	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	13488	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -13664,7 +13665,7 @@ fn zirMod(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -13664,7 +13665,7 @@ fn zirMod(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
13664	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	13665	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
13665	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	13666	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
13666	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	13667	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13667	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod);	13668	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
13668		13669
13669	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	13670	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
13670	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	13671	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -13766,7 +13767,7 @@ fn zirRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -13766,7 +13767,7 @@ fn zirRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
13766	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();	13767	const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
13767	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();	13768	const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
13768	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);	13769	try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13769	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .rem);	13770	try sema.checkInvalidPtrArithmetic(block, src, lhs_ty);
13770		13771
13771	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };	13772	const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
13772	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{	13773	const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
...	@@ -14106,12 +14107,7 @@ fn analyzeArithmetic(	...	@@ -14106,12 +14107,7 @@ fn analyzeArithmetic(
14106	const air_tag: Air.Inst.Tag = switch (zir_tag) {	14107	const air_tag: Air.Inst.Tag = switch (zir_tag) {
14107	.add => .ptr_add,	14108	.add => .ptr_add,
14108	.sub => .ptr_sub,	14109	.sub => .ptr_sub,
14109	else => return sema.fail(	14110	else => return sema.fail(block, src, "invalid pointer arithmetic operator", .{}),
14110	block,
14111	src,
14112	"invalid pointer arithmetic operand: '{s}''",
14113	.{@tagName(zir_tag)},
14114	),
14115	};	14111	};
14116	return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);	14112	return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
14117	},	14113	},
...	@@ -19697,7 +19693,7 @@ fn zirTruncate(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -19697,7 +19693,7 @@ fn zirTruncate(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
19697	}	19693	}
19698	}	19694	}
19699		19695
19700	if (try sema.resolveMaybeUndefVal(operand)) \|val\| {	19696	if (try sema.resolveMaybeUndefValIntable(operand)) \|val\| {
19701	if (val.isUndef()) return sema.addConstUndef(dest_ty);	19697	if (val.isUndef()) return sema.addConstUndef(dest_ty);
19702	if (!is_vector) {	19698	if (!is_vector) {
19703	return sema.addConstant(	19699	return sema.addConstant(
...	@@ -19901,7 +19897,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!	...	@@ -19901,7 +19897,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!
19901	const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };	19897	const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
19902	const operand = try sema.resolveInst(inst_data.operand);	19898	const operand = try sema.resolveInst(inst_data.operand);
19903	const operand_ty = sema.typeOf(operand);	19899	const operand_ty = sema.typeOf(operand);
19904	_ = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);	19900	const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
19905		19901
19906	if (try sema.typeHasOnePossibleValue(operand_ty)) \|val\| {	19902	if (try sema.typeHasOnePossibleValue(operand_ty)) \|val\| {
19907	return sema.addConstant(operand_ty, val);	19903	return sema.addConstant(operand_ty, val);
...	@@ -19909,7 +19905,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!	...	@@ -19909,7 +19905,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!
19909		19905
19910	const target = sema.mod.getTarget();	19906	const target = sema.mod.getTarget();
19911	switch (operand_ty.zigTypeTag()) {	19907	switch (operand_ty.zigTypeTag()) {
19912	.Int, .ComptimeInt => {	19908	.Int => {
19913	const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) \|val\| {	19909	const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) \|val\| {
19914	if (val.isUndef()) return sema.addConstUndef(operand_ty);	19910	if (val.isUndef()) return sema.addConstUndef(operand_ty);
19915	const result_val = try val.bitReverse(operand_ty, target, sema.arena);	19911	const result_val = try val.bitReverse(operand_ty, target, sema.arena);
...	@@ -19929,7 +19925,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!	...	@@ -19929,7 +19925,7 @@ fn zirBitReverse(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!
19929	const elems = try sema.arena.alloc(Value, vec_len);	19925	const elems = try sema.arena.alloc(Value, vec_len);
19930	for (elems) \|*elem, i\| {	19926	for (elems) \|*elem, i\| {
19931	const elem_val = val.elemValueBuffer(sema.mod, i, &elem_buf);	19927	const elem_val = val.elemValueBuffer(sema.mod, i, &elem_buf);
19932	elem.* = try elem_val.bitReverse(operand_ty, target, sema.arena);	19928	elem.* = try elem_val.bitReverse(scalar_ty, target, sema.arena);
19933	}	19929	}
19934	return sema.addConstant(	19930	return sema.addConstant(
19935	operand_ty,	19931	operand_ty,
...	@@ -20028,7 +20024,6 @@ fn checkInvalidPtrArithmetic(	...	@@ -20028,7 +20024,6 @@ fn checkInvalidPtrArithmetic(
20028	block: *Block,	20024	block: *Block,
20029	src: LazySrcLoc,	20025	src: LazySrcLoc,
20030	ty: Type,	20026	ty: Type,
20031	zir_tag: Zir.Inst.Tag,
20032	) CompileError!void {	20027	) CompileError!void {
20033	switch (try ty.zigTypeTagOrPoison()) {	20028	switch (try ty.zigTypeTagOrPoison()) {
20034	.Pointer => switch (ty.ptrSize()) {	20029	.Pointer => switch (ty.ptrSize()) {
...	@@ -20036,8 +20031,8 @@ fn checkInvalidPtrArithmetic(	...	@@ -20036,8 +20031,8 @@ fn checkInvalidPtrArithmetic(
20036	.Many, .C => return sema.fail(	20031	.Many, .C => return sema.fail(
20037	block,	20032	block,
20038	src,	20033	src,
20039	"invalid pointer arithmetic operand: '{s}''",	20034	"invalid pointer arithmetic operator",
20040	.{@tagName(zir_tag)},	20035	.{},
20041	),	20036	),
20042	},	20037	},
20043	else => return,	20038	else => return,

Merge pull request #14403 from Vexu/fixes