Skip to content

Commit a51c765

Browse files
andrewrkandrewrk
authored
Merge pull request #14403 from Vexu/fixes
Misc fixes
2 parents f85c01d + aa626de commit a51c765

File tree

13 files changed

+366
-223
lines changed

13 files changed

+366
-223
lines changed

‎src/Sema.zig

Lines changed: 26 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -3948,6 +3948,7 @@ fn validateArrayInitTy(
39483948
return;
39493949
},
39503950
.Struct => if (ty.isTuple()) {
3951+
_ = try sema.resolveTypeFields(ty);
39513952
const array_len = ty.arrayLen();
39523953
if (extra.init_count > array_len) {
39533954
return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
@@ -4642,11 +4643,11 @@ fn failWithBadMemberAccess(
46424643
.Enum => "enum",
46434644
else => unreachable,
46444645
};
4645-
if (sema.mod.declIsRoot(agg_ty.getOwnerDecl())) {
4646+
if (agg_ty.getOwnerDeclOrNull()) |some| if (sema.mod.declIsRoot(some)) {
46464647
return sema.fail(block, field_src, "root struct of file '{}' has no member named '{s}'", .{
46474648
agg_ty.fmt(sema.mod), field_name,
46484649
});
4649-
}
4650+
};
46504651
const msg = msg: {
46514652
const msg = try sema.errMsg(block, field_src, "{s} '{}' has no member named '{s}'", .{
46524653
kw_name, agg_ty.fmt(sema.mod), field_name,
@@ -7514,7 +7515,7 @@ fn resolveGenericInstantiationType(
75147515
}
75157516

75167517
fn resolveTupleLazyValues(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!void {
7517-
if (!ty.isSimpleTuple()) return;
7518+
if (!ty.isSimpleTupleOrAnonStruct()) return;
75187519
const tuple = ty.tupleFields();
75197520
for (tuple.values) |field_val, i| {
75207521
try sema.resolveTupleLazyValues(block, src, tuple.types[i]);
@@ -11771,8 +11772,8 @@ fn zirShl(
1177111772
// TODO coerce rhs if air_tag is not shl_sat
1177211773
const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
1177311774

11774-
const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs);
11775-
const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs);
11775+
const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);
11776+
const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);
1177611777

1177711778
if (maybe_rhs_val) |rhs_val| {
1177811779
if (rhs_val.isUndef()) {
@@ -11842,7 +11843,7 @@ fn zirShl(
1184211843
if (scalar_ty.zigTypeTag() == .ComptimeInt) {
1184311844
break :val shifted.wrapped_result;
1184411845
}
11845-
if (shifted.overflow_bit.compareAllWithZero(.eq)) {
11846+
if (shifted.overflow_bit.compareAllWithZero(.eq, sema.mod)) {
1184611847
break :val shifted.wrapped_result;
1184711848
}
1184811849
return sema.fail(block, src, "operation caused overflow", .{});
@@ -11959,8 +11960,8 @@ fn zirShr(
1195911960
const target = sema.mod.getTarget();
1196011961
const scalar_ty = lhs_ty.scalarType();
1196111962

11962-
const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs);
11963-
const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs);
11963+
const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);
11964+
const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);
1196411965

1196511966
const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {
1196611967
if (rhs_val.isUndef()) {
@@ -12799,7 +12800,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1279912800
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1280012801
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1280112802
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);
1280312804

1280412805
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1280512806
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
1283112832
const lhs_val = maybe_lhs_val orelse unreachable;
1283212833
const rhs_val = maybe_rhs_val orelse unreachable;
1283312834
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)) {
1283512836
return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{
1283612837
@tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),
1283712838
});
@@ -12959,7 +12960,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1295912960
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1296012961
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1296112962
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);
1296312964

1296412965
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1296512966
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
1302413025
if (maybe_rhs_val) |rhs_val| {
1302513026
if (is_int) {
1302613027
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))) {
1302813029
return sema.fail(block, src, "exact division produced remainder", .{});
1302913030
}
1303013031
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
1303513036
return sema.addConstant(resolved_type, res);
1303613037
} else {
1303713038
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))) {
1303913040
return sema.fail(block, src, "exact division produced remainder", .{});
1304013041
}
1304113042
return sema.addConstant(
@@ -13122,7 +13123,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1312213123
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1312313124
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1312413125
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);
1312613127

1312713128
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1312813129
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
1323813239
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1323913240
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1324013241
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);
1324213243

1324313244
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1324413245
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.
1348113482
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1348213483
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1348313484
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);
1348513486

1348613487
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1348713488
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
1366413665
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1366513666
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1366613667
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);
1366813669

1366913670
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1367013671
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
1376613767
const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
1376713768
const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
1376813769
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);
1377013771

1377113772
const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
1377213773
const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
@@ -14106,12 +14107,7 @@ fn analyzeArithmetic(
1410614107
const air_tag: Air.Inst.Tag = switch (zir_tag) {
1410714108
.add => .ptr_add,
1410814109
.sub => .ptr_sub,
14109-
else => return sema.fail(
14110-
block,
14111-
src,
14112-
"invalid pointer arithmetic operand: '{s}''",
14113-
.{@tagName(zir_tag)},
14114-
),
14110+
else => return sema.fail(block, src, "invalid pointer arithmetic operator", .{}),
1411514111
};
1411614112
return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
1411714113
},
@@ -19697,7 +19693,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1969719693
}
1969819694
}
1969919695

19700-
if (try sema.resolveMaybeUndefVal(operand)) |val| {
19696+
if (try sema.resolveMaybeUndefValIntable(operand)) |val| {
1970119697
if (val.isUndef()) return sema.addConstUndef(dest_ty);
1970219698
if (!is_vector) {
1970319699
return sema.addConstant(
@@ -19901,15 +19897,15 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1990119897
const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
1990219898
const operand = try sema.resolveInst(inst_data.operand);
1990319899
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);
1990519901

1990619902
if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
1990719903
return sema.addConstant(operand_ty, val);
1990819904
}
1990919905

1991019906
const target = sema.mod.getTarget();
1991119907
switch (operand_ty.zigTypeTag()) {
19912-
.Int, .ComptimeInt => {
19908+
.Int => {
1991319909
const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
1991419910
if (val.isUndef()) return sema.addConstUndef(operand_ty);
1991519911
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!
1992919925
const elems = try sema.arena.alloc(Value, vec_len);
1993019926
for (elems) |*elem, i| {
1993119927
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);
1993319929
}
1993419930
return sema.addConstant(
1993519931
operand_ty,
@@ -20028,16 +20024,15 @@ fn checkInvalidPtrArithmetic(
2002820024
block: *Block,
2002920025
src: LazySrcLoc,
2003020026
ty: Type,
20031-
zir_tag: Zir.Inst.Tag,
2003220027
) CompileError!void {
2003320028
switch (try ty.zigTypeTagOrPoison()) {
2003420029
.Pointer => switch (ty.ptrSize()) {
2003520030
.One, .Slice => return,
2003620031
.Many, .C => return sema.fail(
2003720032
block,
2003820033
src,
20039-
"invalid pointer arithmetic operand: '{s}''",
20040-
.{@tagName(zir_tag)},
20034+
"invalid pointer arithmetic operator",
20035+
.{},
2004120036
),
2004220037
},
2004320038
else => return,

0 commit comments

Comments
 (0)