Commit 507dc1f2e7fac212e79f152e557cbec98a3c30e9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-07-30 16:05:46-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-07-30 16:17:59-07:00
log	507dc1f2e7fac212e79f152e557cbec98a3c30e9
tree	34b057caf8ebadef2d199af39b1b44fca48c1a23
parent	84039a57e4684e8df10e657bb76c6acb3fb89238

stage2: fix hashing and comparison design flaw with Value

 * `Value.toType` accepts a buffer parameter instead of an allocator
   parameter and can no longer fail.
 * Module: remove the unused `mod: *Module` parameter from various
   functions.
 * `Value.compare` now accepts a `Type` parameter which indicates the
   type of both operands. There is also a `Value.compareHetero` which
   accepts only Value parameters and supports comparing mixed types.
   Likewise, `Value.eql` requires a `Type` parameter.
 * `Value.hash` is removed; instead the hash map context structs now
   have a `ty: Type` field, and the hash function lives there, where it
   has access to a Value's Type when it computes a hash.
   - This allowed the hash function to be greatly simplified and sound
     in the sense that the same Values, even with different
     representations, always hash to the same thing.
 * Sema: Fix source location of zirCmp when an operand is runtime known
   but needs to be comptime known.
 * Remove unused target parameter from `Value.floatCast`.

6 files changed, 229 insertions(+), 442 deletions(-)

src/Air.zig+2-1

...	@@ -503,7 +503,8 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {	...	@@ -503,7 +503,8 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
503	pub fn getRefType(air: Air, ref: Air.Inst.Ref) Type {	503	pub fn getRefType(air: Air, ref: Air.Inst.Ref) Type {
504	const ref_int = @enumToInt(ref);	504	const ref_int = @enumToInt(ref);
505	if (ref_int < Air.Inst.Ref.typed_value_map.len) {	505	if (ref_int < Air.Inst.Ref.typed_value_map.len) {
506	return Air.Inst.Ref.typed_value_map[ref_int].val.toType(undefined) catch unreachable;	506	var buffer: Value.ToTypeBuffer = undefined;
		507	return Air.Inst.Ref.typed_value_map[ref_int].val.toType(&buffer);
507	}	508	}
508	const inst_index = ref_int - Air.Inst.Ref.typed_value_map.len;	509	const inst_index = ref_int - Air.Inst.Ref.typed_value_map.len;
509	const air_tags = air.instructions.items(.tag);	510	const air_tags = air.instructions.items(.tag);

src/Module.zig+2-9

 @@ -4299,7 +4299,6 @@ pub fn simplePtrType(
 }
 pub fn ptrType(
-    mod: *Module,
     arena: *Allocator,
     elem_ty: Type,
     sentinel: ?Value,
 @@ -4311,7 +4310,6 @@ pub fn ptrType(
     @"volatile": bool,
     size: std.builtin.TypeInfo.Pointer.Size,
 ) Allocator.Error!Type {
-    _ = mod;
     assert(host_size == 0 or bit_offset < host_size * 8);
     // TODO check if type can be represented by simplePtrType
 @@ -4328,8 +4326,7 @@ pub fn ptrType(
     });
 }
-pub fn optionalType(mod: *Module, arena: *Allocator, child_type: Type) Allocator.Error!Type {
+pub fn optionalType(arena: *Allocator, child_type: Type) Allocator.Error!Type {
-    _ = mod;
     switch (child_type.tag()) {
         .single_const_pointer => return Type.Tag.optional_single_const_pointer.create(
             arena,
 @@ -4344,16 +4341,14 @@ pub fn optionalType(mod: *Module, arena: *Allocator, child_type: Type) Allocator
 }
 pub fn arrayType(
-    mod: *Module,
     arena: *Allocator,
     len: u64,
     sentinel: ?Value,
     elem_type: Type,
 ) Allocator.Error!Type {
-    _ = mod;
     if (elem_type.eql(Type.initTag(.u8))) {
         if (sentinel) |some| {
-            if (some.eql(Value.initTag(.zero))) {
+            if (some.eql(Value.initTag(.zero), elem_type)) {
                 return Type.Tag.array_u8_sentinel_0.create(arena, len);
             }
         } else {
 @@ -4376,12 +4371,10 @@ pub fn arrayType(
 }
 pub fn errorUnionType(
-    mod: *Module,
     arena: *Allocator,
     error_set: Type,
     payload: Type,
 ) Allocator.Error!Type {
-    _ = mod;
     assert(error_set.zigTypeTag() == .ErrorSet);
     if (error_set.eql(Type.initTag(.anyerror)) and payload.eql(Type.initTag(.void))) {
         return Type.initTag(.anyerror_void_error_union);

src/RangeSet.zig+15-8

 @@ -1,5 +1,6 @@
 const std = @import("std");
 const Order = std.math.Order;
+const Type = @import("type.zig").Type;
 const Value = @import("value.zig").Value;
 const RangeSet = @This();
 const SwitchProngSrc = @import("Module.zig").SwitchProngSrc;
 @@ -22,9 +23,15 @@ pub fn deinit(self: *RangeSet) void {
     self.ranges.deinit();
 }
-pub fn add(self: *RangeSet, first: Value, last: Value, src: SwitchProngSrc) !?SwitchProngSrc {
+pub fn add(
+    self: *RangeSet,
+    first: Value,
+    last: Value,
+    ty: Type,
+    src: SwitchProngSrc,
+) !?SwitchProngSrc {
     for (self.ranges.items) |range| {
-        if (last.compare(.gte, range.first) and first.compare(.lte, range.last)) {
+        if (last.compare(.gte, range.first, ty) and first.compare(.lte, range.last, ty)) {
             return range.src; // They overlap.
         }
     }
 @@ -37,18 +44,18 @@ pub fn add(self: *RangeSet, first: Value, last: Value, src: SwitchProngSrc) !?Sw
 }
 /// Assumes a and b do not overlap
-fn lessThan(_: void, a: Range, b: Range) bool {
+fn lessThan(ty: Type, a: Range, b: Range) bool {
-    return a.first.compare(.lt, b.first);
+    return a.first.compare(.lt, b.first, ty);
 }
-pub fn spans(self: *RangeSet, first: Value, last: Value) !bool {
+pub fn spans(self: *RangeSet, first: Value, last: Value, ty: Type) !bool {
     if (self.ranges.items.len == 0)
         return false;
-    std.sort.sort(Range, self.ranges.items, {}, lessThan);
+    std.sort.sort(Range, self.ranges.items, ty, lessThan);
-    if (!self.ranges.items[0].first.eql(first) or
+    if (!self.ranges.items[0].first.eql(first, ty) or
-        !self.ranges.items[self.ranges.items.len - 1].last.eql(last))
+        !self.ranges.items[self.ranges.items.len - 1].last.eql(last, ty))
     {
         return false;
     }

src/Sema.zig+75-59

 @@ -634,7 +634,9 @@ fn analyzeAsType(
     const wanted_type = Type.initTag(.@"type");
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
     const val = try sema.resolveConstValue(block, src, coerced_inst);
-    return val.toType(sema.arena);
+    var buffer: Value.ToTypeBuffer = undefined;
+    const ty = val.toType(&buffer);
+    return ty.copy(sema.arena);
 }
 /// May return Value Tags: `variable`, `undef`.
 @@ -1022,7 +1024,9 @@ fn zirEnumDecl(
         if (bag != 0) break true;
     } else false;
     if (any_values) {
-        try enum_obj.values.ensureCapacity(&new_decl_arena.allocator, fields_len);
+        try enum_obj.values.ensureTotalCapacityContext(&new_decl_arena.allocator, fields_len, .{
+            .ty = tag_ty,
+        });
     }
     {
 @@ -1100,10 +1104,10 @@ fn zirEnumDecl(
             // that points to this default value expression rather than the struct.
             // But only resolve the source location if we need to emit a compile error.
             const tag_val = (try sema.resolveInstConst(block, src, tag_val_ref)).val;
-            enum_obj.values.putAssumeCapacityNoClobber(tag_val, {});
+            enum_obj.values.putAssumeCapacityNoClobberContext(tag_val, {}, .{ .ty = tag_ty });
         } else if (any_values) {
             const tag_val = try Value.Tag.int_u64.create(&new_decl_arena.allocator, field_i);
-            enum_obj.values.putAssumeCapacityNoClobber(tag_val, {});
+            enum_obj.values.putAssumeCapacityNoClobberContext(tag_val, {}, .{ .ty = tag_ty });
         }
     }
 @@ -2516,7 +2520,7 @@ fn zirOptionalType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Compi
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
     const child_type = try sema.resolveType(block, src, inst_data.operand);
-    const opt_type = try sema.mod.optionalType(sema.arena, child_type);
+    const opt_type = try Module.optionalType(sema.arena, child_type);
     return sema.addType(opt_type);
 }
 @@ -2547,11 +2551,10 @@ fn zirArrayType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileE
     const tracy = trace(@src());
     defer tracy.end();
-    // TODO these should be lazily evaluated
     const bin_inst = sema.code.instructions.items(.data)[inst].bin;
     const len = try sema.resolveInstConst(block, .unneeded, bin_inst.lhs);
     const elem_type = try sema.resolveType(block, .unneeded, bin_inst.rhs);
-    const array_ty = try sema.mod.arrayType(sema.arena, len.val.toUnsignedInt(), null, elem_type);
+    const array_ty = try Module.arrayType(sema.arena, len.val.toUnsignedInt(), null, elem_type);
     return sema.addType(array_ty);
 }
 @@ -2560,13 +2563,12 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index)
     const tracy = trace(@src());
     defer tracy.end();
-    // TODO these should be lazily evaluated
     const inst_data = sema.code.instructions.items(.data)[inst].array_type_sentinel;
     const len = try sema.resolveInstConst(block, .unneeded, inst_data.len);
     const extra = sema.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data;
     const sentinel = try sema.resolveInstConst(block, .unneeded, extra.sentinel);
     const elem_type = try sema.resolveType(block, .unneeded, extra.elem_type);
-    const array_ty = try sema.mod.arrayType(sema.arena, len.val.toUnsignedInt(), sentinel.val, elem_type);
+    const array_ty = try Module.arrayType(sema.arena, len.val.toUnsignedInt(), sentinel.val, elem_type);
     return sema.addType(array_ty);
 }
 @@ -2599,7 +2601,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Com
             error_union.elemType(),
         });
     }
-    const err_union_ty = try sema.mod.errorUnionType(sema.arena, error_union, payload);
+    const err_union_ty = try Module.errorUnionType(sema.arena, error_union, payload);
     return sema.addType(err_union_ty);
 }
 @@ -3890,6 +3892,7 @@ fn analyzeSwitch(
                         block,
                         &range_set,
                         item_ref,
+                        operand_ty,
                         src_node_offset,
                         .{ .scalar = scalar_i },
                     );
 @@ -3912,6 +3915,7 @@ fn analyzeSwitch(
                             block,
                             &range_set,
                             item_ref,
+                            operand_ty,
                             src_node_offset,
                             .{ .multi = .{ .prong = multi_i, .item = @intCast(u32, item_i) } },
                         );
 @@ -3929,6 +3933,7 @@ fn analyzeSwitch(
                             &range_set,
                             item_first,
                             item_last,
+                            operand_ty,
                             src_node_offset,
                             .{ .range = .{ .prong = multi_i, .item = range_i } },
                         );
 @@ -3945,7 +3950,7 @@ fn analyzeSwitch(
                     const min_int = try operand_ty.minInt(&arena, mod.getTarget());
                     const max_int = try operand_ty.maxInt(&arena, mod.getTarget());
-                    if (try range_set.spans(min_int, max_int)) {
+                    if (try range_set.spans(min_int, max_int, operand_ty)) {
                         if (special_prong == .@"else") {
                             return mod.fail(
                                 &block.base,
 @@ -4050,7 +4055,7 @@ fn analyzeSwitch(
                 );
             }
-            var seen_values = ValueSrcMap.init(gpa);
+            var seen_values = ValueSrcMap.initContext(gpa, .{ .ty = operand_ty });
             defer seen_values.deinit();
             var extra_index: usize = special.end;
 @@ -4161,7 +4166,7 @@ fn analyzeSwitch(
                 const item = sema.resolveInst(item_ref);
                 // Validation above ensured these will succeed.
                 const item_val = sema.resolveConstValue(&child_block, .unneeded, item) catch unreachable;
-                if (operand_val.eql(item_val)) {
+                if (operand_val.eql(item_val, operand_ty)) {
                     return sema.resolveBlockBody(block, src, &child_block, body, merges);
                 }
             }
 @@ -4183,7 +4188,7 @@ fn analyzeSwitch(
                     const item = sema.resolveInst(item_ref);
                     // Validation above ensured these will succeed.
                     const item_val = sema.resolveConstValue(&child_block, .unneeded, item) catch unreachable;
-                    if (operand_val.eql(item_val)) {
+                    if (operand_val.eql(item_val, operand_ty)) {
                         return sema.resolveBlockBody(block, src, &child_block, body, merges);
                     }
                 }
 @@ -4198,8 +4203,8 @@ fn analyzeSwitch(
                     // Validation above ensured these will succeed.
                     const first_tv = sema.resolveInstConst(&child_block, .unneeded, item_first) catch unreachable;
                     const last_tv = sema.resolveInstConst(&child_block, .unneeded, item_last) catch unreachable;
-                    if (Value.compare(operand_val, .gte, first_tv.val) and
+                    if (Value.compare(operand_val, .gte, first_tv.val, operand_ty) and
-                        Value.compare(operand_val, .lte, last_tv.val))
+                        Value.compare(operand_val, .lte, last_tv.val, operand_ty))
                     {
                         return sema.resolveBlockBody(block, src, &child_block, body, merges);
                     }
 @@ -4450,12 +4455,13 @@ fn validateSwitchRange(
     range_set: *RangeSet,
     first_ref: Zir.Inst.Ref,
     last_ref: Zir.Inst.Ref,
+    operand_ty: Type,
     src_node_offset: i32,
     switch_prong_src: Module.SwitchProngSrc,
 ) CompileError!void {
     const first_val = (try sema.resolveSwitchItemVal(block, first_ref, src_node_offset, switch_prong_src, .first)).val;
     const last_val = (try sema.resolveSwitchItemVal(block, last_ref, src_node_offset, switch_prong_src, .last)).val;
-    const maybe_prev_src = try range_set.add(first_val, last_val, switch_prong_src);
+    const maybe_prev_src = try range_set.add(first_val, last_val, operand_ty, switch_prong_src);
     return sema.validateSwitchDupe(block, maybe_prev_src, switch_prong_src, src_node_offset);
 }
 @@ -4464,11 +4470,12 @@ fn validateSwitchItem(
     block: *Scope.Block,
     range_set: *RangeSet,
     item_ref: Zir.Inst.Ref,
+    operand_ty: Type,
     src_node_offset: i32,
     switch_prong_src: Module.SwitchProngSrc,
 ) CompileError!void {
     const item_val = (try sema.resolveSwitchItemVal(block, item_ref, src_node_offset, switch_prong_src, .none)).val;
-    const maybe_prev_src = try range_set.add(item_val, item_val, switch_prong_src);
+    const maybe_prev_src = try range_set.add(item_val, item_val, operand_ty, switch_prong_src);
     return sema.validateSwitchDupe(block, maybe_prev_src, switch_prong_src, src_node_offset);
 }
 @@ -5137,20 +5144,26 @@ fn zirCmp(
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+    const runtime_src: LazySrcLoc = src: {
-        if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
-            if (lhs_val.isUndef() or rhs_val.isUndef()) {
+            if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
-                return sema.addConstUndef(resolved_type);
+                if (lhs_val.isUndef() or rhs_val.isUndef()) {
-            }
+                    return sema.addConstUndef(resolved_type);
-            if (lhs_val.compare(op, rhs_val)) {
+                }
-                return Air.Inst.Ref.bool_true;
+                if (lhs_val.compare(op, rhs_val, resolved_type)) {
+                    return Air.Inst.Ref.bool_true;
+                } else {
+                    return Air.Inst.Ref.bool_false;
+                }
             } else {
-                return Air.Inst.Ref.bool_false;
+                break :src rhs_src;
             }
+        } else {
+            break :src lhs_src;
         }
-    }
+    };
+    try sema.requireRuntimeBlock(block, runtime_src);
-    try sema.requireRuntimeBlock(block, src);
     const tag: Air.Inst.Tag = switch (op) {
         .lt => .cmp_lt,
         .lte => .cmp_lte,
 @@ -5626,7 +5639,7 @@ fn zirPtrTypeSimple(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     const inst_data = sema.code.instructions.items(.data)[inst].ptr_type_simple;
     const elem_type = try sema.resolveType(block, .unneeded, inst_data.elem_type);
-    const ty = try sema.mod.ptrType(
+    const ty = try Module.ptrType(
         sema.arena,
         elem_type,
         null,
 @@ -5680,7 +5693,7 @@ fn zirPtrType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
     const elem_type = try sema.resolveType(block, .unneeded, extra.data.elem_type);
-    const ty = try sema.mod.ptrType(
+    const ty = try Module.ptrType(
         sema.arena,
         elem_type,
         sentinel,
 @@ -6569,7 +6582,7 @@ fn panicWithMsg(
     const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
     const ptr_stack_trace_ty = try Module.simplePtrType(arena, stack_trace_ty, true, .One);
     const null_stack_trace = try sema.addConstant(
-        try mod.optionalType(arena, ptr_stack_trace_ty),
+        try Module.optionalType(arena, ptr_stack_trace_ty),
         Value.initTag(.null_value),
     );
     const args = try arena.create([2]Air.Inst.Ref);
 @@ -6713,7 +6726,8 @@ fn fieldVal(
         },
         .Type => {
             const val = (try sema.resolveDefinedValue(block, object_src, object)).?;
-            const child_type = try val.toType(arena);
+            var to_type_buffer: Value.ToTypeBuffer = undefined;
+            const child_type = val.toType(&to_type_buffer);
             switch (child_type.zigTypeTag()) {
                 .ErrorSet => {
                     // TODO resolve inferred error sets
 @@ -6733,7 +6747,7 @@ fn fieldVal(
                     } else (try mod.getErrorValue(field_name)).key;
                     return sema.addConstant(
-                        child_type,
+                        try child_type.copy(arena),
                         try Value.Tag.@"error".create(arena, .{ .name = name }),
                     );
                 },
 @@ -6781,7 +6795,7 @@ fn fieldVal(
                     };
                     const field_index_u32 = @intCast(u32, field_index);
                     const enum_val = try Value.Tag.enum_field_index.create(arena, field_index_u32);
-                    return sema.addConstant(child_type, enum_val);
+                    return sema.addConstant(try child_type.copy(arena), enum_val);
                 },
                 else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
             }
 @@ -6805,7 +6819,6 @@ fn fieldPtr(
     // in `fieldVal`. This function takes a pointer and returns a pointer.
     const mod = sema.mod;
-    const arena = sema.arena;
     const object_ptr_src = src; // TODO better source location
     const object_ptr_ty = sema.typeOf(object_ptr);
     const object_ty = switch (object_ptr_ty.zigTypeTag()) {
 @@ -6887,7 +6900,8 @@ fn fieldPtr(
             _ = try sema.resolveConstValue(block, object_ptr_src, object_ptr);
             const result = try sema.analyzeLoad(block, src, object_ptr, object_ptr_src);
             const val = (sema.resolveDefinedValue(block, src, result) catch unreachable).?;
-            const child_type = try val.toType(arena);
+            var to_type_buffer: Value.ToTypeBuffer = undefined;
+            const child_type = val.toType(&to_type_buffer);
             switch (child_type.zigTypeTag()) {
                 .ErrorSet => {
                     // TODO resolve inferred error sets
 @@ -6902,15 +6916,14 @@ fn fieldPtr(
                             }
                         }
                         return mod.fail(&block.base, src, "no error named '{s}' in '{}'", .{
-                            field_name,
+                            field_name, child_type,
-                            child_type,
                         });
                     } else (try mod.getErrorValue(field_name)).key;
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
                     return sema.analyzeDeclRef(try anon_decl.finish(
-                        child_type,
+                        try child_type.copy(anon_decl.arena()),
                         try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
                     ));
                 },
 @@ -6960,7 +6973,7 @@ fn fieldPtr(
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
                     return sema.analyzeDeclRef(try anon_decl.finish(
-                        child_type,
+                        try child_type.copy(anon_decl.arena()),
                         try Value.Tag.enum_field_index.create(anon_decl.arena(), field_index_u32),
                     ));
                 },
 @@ -7352,7 +7365,7 @@ fn coerce(
                         if (src_sentinel) |src_s| {
                             if (dst_sentinel) |dst_s| {
-                                if (src_s.eql(dst_s)) {
+                                if (src_s.eql(dst_s, dst_elem_type)) {
                                     return sema.coerceArrayPtrToMany(block, dest_type, inst, inst_src);
                                 }
                             }
 @@ -7474,7 +7487,7 @@ fn coerceNum(
         }
     } else if (dst_zig_tag == .ComptimeFloat or dst_zig_tag == .Float) {
         if (src_zig_tag == .Float or src_zig_tag == .ComptimeFloat) {
-            const res = val.floatCast(sema.arena, dest_type, target) catch |err| switch (err) {
+            const res = val.floatCast(sema.arena, dest_type) catch |err| switch (err) {
                 error.Overflow => return sema.mod.fail(
                     &block.base,
                     inst_src,
 @@ -7813,12 +7826,12 @@ fn analyzeSlice(
                     array_type.sentinel()
                 else
                     slice_sentinel;
-                return_elem_type = try sema.mod.arrayType(sema.arena, len, array_sentinel, elem_type);
+                return_elem_type = try Module.arrayType(sema.arena, len, array_sentinel, elem_type);
                 return_ptr_size = .One;
             }
         }
     }
-    const return_type = try sema.mod.ptrType(
+    const return_type = try Module.ptrType(
         sema.arena,
         return_elem_type,
         if (end_opt == .none) slice_sentinel else null,
 @@ -7858,39 +7871,42 @@ fn cmpNumeric(
     if (lhs_ty_tag == .Vector and rhs_ty_tag == .Vector) {
         if (lhs_ty.arrayLen() != rhs_ty.arrayLen()) {
             return sema.mod.fail(&block.base, src, "vector length mismatch: {d} and {d}", .{
-                lhs_ty.arrayLen(),
+                lhs_ty.arrayLen(), rhs_ty.arrayLen(),
-                rhs_ty.arrayLen(),
             });
         }
         return sema.mod.fail(&block.base, src, "TODO implement support for vectors in cmpNumeric", .{});
     } else if (lhs_ty_tag == .Vector or rhs_ty_tag == .Vector) {
         return sema.mod.fail(&block.base, src, "mixed scalar and vector operands to comparison operator: '{}' and '{}'", .{
-            lhs_ty,
+            lhs_ty, rhs_ty,
-            rhs_ty,
         });
     }
-    if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
+    const runtime_src: LazySrcLoc = src: {
-        if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
-            if (lhs_val.isUndef() or rhs_val.isUndef()) {
+            if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
-                return sema.addConstUndef(Type.initTag(.bool));
+                if (lhs_val.isUndef() or rhs_val.isUndef()) {
-            }
+                    return sema.addConstUndef(Type.initTag(.bool));
-            if (Value.compare(lhs_val, op, rhs_val)) {
+                }
-                return Air.Inst.Ref.bool_true;
+                if (Value.compareHetero(lhs_val, op, rhs_val)) {
+                    return Air.Inst.Ref.bool_true;
+                } else {
+                    return Air.Inst.Ref.bool_false;
+                }
             } else {
-                return Air.Inst.Ref.bool_false;
+                break :src rhs_src;
             }
+        } else {
+            break :src lhs_src;
         }
-    }
+    };
     // TODO handle comparisons against lazy zero values
     // Some values can be compared against zero without being runtime known or without forcing
     // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to
     // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout
     // of this function if we don't need to.
+    try sema.requireRuntimeBlock(block, runtime_src);
-    // It must be a runtime comparison.
-    try sema.requireRuntimeBlock(block, src);
     // For floats, emit a float comparison instruction.
     const lhs_is_float = switch (lhs_ty_tag) {
         .Float, .ComptimeFloat => true,

src/type.zig+30-13

 @@ -426,7 +426,7 @@ pub const Type = extern union {
                 const sentinel_b = info_b.sentinel;
                 if (sentinel_a) |sa| {
                     if (sentinel_b) |sb| {
-                        if (!sa.eql(sb))
+                        if (!sa.eql(sb, info_a.pointee_type))
                             return false;
                     } else {
                         return false;
 @@ -455,13 +455,14 @@ pub const Type = extern union {
             .Array, .Vector => {
                 if (a.arrayLen() != b.arrayLen())
                     return false;
-                if (!a.elemType().eql(b.elemType()))
+                const elem_ty = a.elemType();
+                if (!elem_ty.eql(b.elemType()))
                     return false;
                 const sentinel_a = a.sentinel();
                 const sentinel_b = b.sentinel();
                 if (sentinel_a) |sa| {
                     if (sentinel_b) |sb| {
-                        return sa.eql(sb);
+                        return sa.eql(sb, elem_ty);
                     } else {
                         return false;
                     }
 @@ -2744,29 +2745,37 @@ pub const Type = extern union {
             return @as(usize, payload.data);
         }
         const S = struct {
-            fn fieldWithRange(int_val: Value, end: usize) ?usize {
+            fn fieldWithRange(int_ty: Type, int_val: Value, end: usize) ?usize {
                 if (int_val.compareWithZero(.lt)) return null;
                 var end_payload: Value.Payload.U64 = .{
                     .base = .{ .tag = .int_u64 },
                     .data = end,
                 };
                 const end_val = Value.initPayload(&end_payload.base);
-                if (int_val.compare(.gte, end_val)) return null;
+                if (int_val.compare(.gte, end_val, int_ty)) return null;
                 return @intCast(usize, int_val.toUnsignedInt());
             }
         };
         switch (ty.tag()) {
             .enum_full, .enum_nonexhaustive => {
                 const enum_full = ty.cast(Payload.EnumFull).?.data;
+                const tag_ty = enum_full.tag_ty;
                 if (enum_full.values.count() == 0) {
-                    return S.fieldWithRange(enum_tag, enum_full.fields.count());
+                    return S.fieldWithRange(tag_ty, enum_tag, enum_full.fields.count());
                 } else {
-                    return enum_full.values.getIndex(enum_tag);
+                    return enum_full.values.getIndexContext(enum_tag, .{ .ty = tag_ty });
                 }
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                return S.fieldWithRange(enum_tag, enum_simple.fields.count());
+                const fields_len = enum_simple.fields.count();
+                const bits = std.math.log2_int_ceil(usize, fields_len);
+                var buffer: Payload.Bits = .{
+                    .base = .{ .tag = .int_unsigned },
+                    .data = bits,
+                };
+                const tag_ty = Type.initPayload(&buffer.base);
+                return S.fieldWithRange(tag_ty, enum_tag, fields_len);
             },
             .atomic_ordering,
             .atomic_rmw_op,
 @@ -2875,14 +2884,14 @@ pub const Type = extern union {
     /// Asserts the type is an enum.
     pub fn enumHasInt(ty: Type, int: Value, target: Target) bool {
         const S = struct {
-            fn intInRange(int_val: Value, end: usize) bool {
+            fn intInRange(tag_ty: Type, int_val: Value, end: usize) bool {
                 if (int_val.compareWithZero(.lt)) return false;
                 var end_payload: Value.Payload.U64 = .{
                     .base = .{ .tag = .int_u64 },
                     .data = end,
                 };
                 const end_val = Value.initPayload(&end_payload.base);
-                if (int_val.compare(.gte, end_val)) return false;
+                if (int_val.compare(.gte, end_val, tag_ty)) return false;
                 return true;
             }
         };
 @@ -2890,15 +2899,23 @@ pub const Type = extern union {
             .enum_nonexhaustive => return int.intFitsInType(ty, target),
             .enum_full => {
                 const enum_full = ty.castTag(.enum_full).?.data;
+                const tag_ty = enum_full.tag_ty;
                 if (enum_full.values.count() == 0) {
-                    return S.intInRange(int, enum_full.fields.count());
+                    return S.intInRange(tag_ty, int, enum_full.fields.count());
                 } else {
-                    return enum_full.values.contains(int);
+                    return enum_full.values.containsContext(int, .{ .ty = tag_ty });
                 }
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                return S.intInRange(int, enum_simple.fields.count());
+                const fields_len = enum_simple.fields.count();
+                const bits = std.math.log2_int_ceil(usize, fields_len);
+                var buffer: Payload.Bits = .{
+                    .base = .{ .tag = .int_unsigned },
+                    .data = bits,
+                };
+                const tag_ty = Type.initPayload(&buffer.base);
+                return S.intInRange(tag_ty, int, fields_len);
             },
             .atomic_ordering,
             .atomic_rmw_op,

src/value.zig+105-352

...	@@ -653,8 +653,10 @@ pub const Value = extern union {	...	@@ -653,8 +653,10 @@ pub const Value = extern union {
653	unreachable;	653	unreachable;
654	}	654	}
655		655
		656	pub const ToTypeBuffer = Type.Payload.Bits;
		657
656	/// Asserts that the value is representable as a type.	658	/// Asserts that the value is representable as a type.
657	pub fn toType(self: Value, allocator: *Allocator) !Type {	659	pub fn toType(self: Value, buffer: *ToTypeBuffer) Type {
658	return switch (self.tag()) {	660	return switch (self.tag()) {
659	.ty => self.castTag(.ty).?.data,	661	.ty => self.castTag(.ty).?.data,
660	.u1_type => Type.initTag(.u1),	662	.u1_type => Type.initTag(.u1),
...	@@ -714,14 +716,13 @@ pub const Value = extern union {	...	@@ -714,14 +716,13 @@ pub const Value = extern union {
714		716
715	.int_type => {	717	.int_type => {
716	const payload = self.castTag(.int_type).?.data;	718	const payload = self.castTag(.int_type).?.data;
717	const new = try allocator.create(Type.Payload.Bits);	719	buffer.* = .{
718	new.* = .{
719	.base = .{	720	.base = .{
720	.tag = if (payload.signed) .int_signed else .int_unsigned,	721	.tag = if (payload.signed) .int_signed else .int_unsigned,
721	},	722	},
722	.data = payload.bits,	723	.data = payload.bits,
723	};	724	};
724	return Type.initPayload(&new.base);	725	return Type.initPayload(&buffer.base);
725	},	726	},
726		727
727	.undef,	728	.undef,
...	@@ -958,9 +959,8 @@ pub const Value = extern union {	...	@@ -958,9 +959,8 @@ pub const Value = extern union {
958		959
959	/// Converts an integer or a float to a float.	960	/// Converts an integer or a float to a float.
960	/// Returns `error.Overflow` if the value does not fit in the new type.	961	/// Returns `error.Overflow` if the value does not fit in the new type.
961	pub fn floatCast(self: Value, allocator: *Allocator, ty: Type, target: Target) !Value {	962	pub fn floatCast(self: Value, allocator: *Allocator, dest_ty: Type) !Value {
962	_ = target;	963	switch (dest_ty.tag()) {
963	switch (ty.tag()) {
964	.f16 => {	964	.f16 => {
965	@panic("TODO add __trunctfhf2 to compiler-rt");	965	@panic("TODO add __trunctfhf2 to compiler-rt");
966	//const res = try Value.Tag.float_16.create(allocator, self.toFloat(f16));	966	//const res = try Value.Tag.float_16.create(allocator, self.toFloat(f16));
...	@@ -970,13 +970,13 @@ pub const Value = extern union {	...	@@ -970,13 +970,13 @@ pub const Value = extern union {
970	},	970	},
971	.f32 => {	971	.f32 => {
972	const res = try Value.Tag.float_32.create(allocator, self.toFloat(f32));	972	const res = try Value.Tag.float_32.create(allocator, self.toFloat(f32));
973	if (!self.eql(res))	973	if (!self.eql(res, dest_ty))
974	return error.Overflow;	974	return error.Overflow;
975	return res;	975	return res;
976	},	976	},
977	.f64 => {	977	.f64 => {
978	const res = try Value.Tag.float_64.create(allocator, self.toFloat(f64));	978	const res = try Value.Tag.float_64.create(allocator, self.toFloat(f64));
979	if (!self.eql(res))	979	if (!self.eql(res, dest_ty))
980	return error.Overflow;	980	return error.Overflow;
981	return res;	981	return res;
982	},	982	},
...	@@ -1083,12 +1083,18 @@ pub const Value = extern union {	...	@@ -1083,12 +1083,18 @@ pub const Value = extern union {
1083	return lhs_bigint.order(rhs_bigint);	1083	return lhs_bigint.order(rhs_bigint);
1084	}	1084	}
1085		1085
1086	/// Asserts the value is comparable.	1086	/// Asserts the value is comparable. Does not take a type parameter because it supports
1087	pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value) bool {	1087	/// comparisons between heterogeneous types.
		1088	pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value) bool {
		1089	return order(lhs, rhs).compare(op);
		1090	}
		1091
		1092	/// Asserts the value is comparable. Both operands have type `ty`.
		1093	pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value, ty: Type) bool {
1088	return switch (op) {	1094	return switch (op) {
1089	.eq => lhs.eql(rhs),	1095	.eq => lhs.eql(rhs, ty),
1090	.neq => !lhs.eql(rhs),	1096	.neq => !lhs.eql(rhs, ty),
1091	else => order(lhs, rhs).compare(op),	1097	else => compareHetero(lhs, op, rhs),
1092	};	1098	};
1093	}	1099	}
1094		1100
...	@@ -1097,11 +1103,11 @@ pub const Value = extern union {	...	@@ -1097,11 +1103,11 @@ pub const Value = extern union {
1097	return orderAgainstZero(lhs).compare(op);	1103	return orderAgainstZero(lhs).compare(op);
1098	}	1104	}
1099		1105
1100	/// TODO we can't compare value equality without also knowing the type to treat	1106	pub fn eql(a: Value, b: Value, ty: Type) bool {
1101	/// the values as
1102	pub fn eql(a: Value, b: Value) bool {
1103	const a_tag = a.tag();	1107	const a_tag = a.tag();
1104	const b_tag = b.tag();	1108	const b_tag = b.tag();
		1109	assert(a_tag != .undef);
		1110	assert(b_tag != .undef);
1105	if (a_tag == b_tag) {	1111	if (a_tag == b_tag) {
1106	switch (a_tag) {	1112	switch (a_tag) {
1107	.void_value, .null_value => return true,	1113	.void_value, .null_value => return true,
...	@@ -1118,230 +1124,106 @@ pub const Value = extern union {	...	@@ -1118,230 +1124,106 @@ pub const Value = extern union {
1118	else => {},	1124	else => {},
1119	}	1125	}
1120	}	1126	}
1121	if (a.isType() and b.isType()) {	1127	if (ty.zigTypeTag() == .Type) {
1122	// 128 bytes should be enough to hold both types	1128	var buf_a: ToTypeBuffer = undefined;
1123	var buf: [128]u8 = undefined;	1129	var buf_b: ToTypeBuffer = undefined;
1124	var fib = std.heap.FixedBufferAllocator.init(&buf);	1130	const a_type = a.toType(&buf_a);
1125	const a_type = a.toType(&fib.allocator) catch unreachable;	1131	const b_type = b.toType(&buf_b);
1126	const b_type = b.toType(&fib.allocator) catch unreachable;
1127	return a_type.eql(b_type);	1132	return a_type.eql(b_type);
1128	}	1133	}
1129	return order(a, b).compare(.eq);	1134	return order(a, b).compare(.eq);
1130	}	1135	}
1131		1136
1132	pub fn hash_u32(self: Value) u32 {	1137	pub const ArrayHashContext = struct {
1133	return @truncate(u32, self.hash());	1138	ty: Type,
1134	}
1135
1136	/// TODO we can't hash without also knowing the type of the value.
1137	/// we have to hash as if there were a canonical value memory layout.
1138	pub fn hash(self: Value) u64 {
1139	var hasher = std.hash.Wyhash.init(0);
1140		1139
1141	switch (self.tag()) {	1140	pub fn hash(self: @This(), v: Value) u32 {
1142	.u1_type,	1141	const other_context: HashContext = .{ .ty = self.ty };
1143	.u8_type,	1142	return @truncate(u32, other_context.hash(v));
1144	.i8_type,	1143	}
1145	.u16_type,	1144	pub fn eql(self: @This(), a: Value, b: Value) bool {
1146	.i16_type,	1145	return a.eql(b, self.ty);
1147	.u32_type,	1146	}
1148	.i32_type,	1147	};
1149	.u64_type,
1150	.i64_type,
1151	.u128_type,
1152	.i128_type,
1153	.usize_type,
1154	.isize_type,
1155	.c_short_type,
1156	.c_ushort_type,
1157	.c_int_type,
1158	.c_uint_type,
1159	.c_long_type,
1160	.c_ulong_type,
1161	.c_longlong_type,
1162	.c_ulonglong_type,
1163	.c_longdouble_type,
1164	.f16_type,
1165	.f32_type,
1166	.f64_type,
1167	.f128_type,
1168	.c_void_type,
1169	.bool_type,
1170	.void_type,
1171	.type_type,
1172	.anyerror_type,
1173	.comptime_int_type,
1174	.comptime_float_type,
1175	.noreturn_type,
1176	.null_type,
1177	.undefined_type,
1178	.fn_noreturn_no_args_type,
1179	.fn_void_no_args_type,
1180	.fn_naked_noreturn_no_args_type,
1181	.fn_ccc_void_no_args_type,
1182	.single_const_pointer_to_comptime_int_type,
1183	.anyframe_type,
1184	.const_slice_u8_type,
1185	.enum_literal_type,
1186	.ty,
1187	.abi_align_default,
1188	=> {
1189	// Directly return Type.hash, toType can only fail for .int_type.
1190	var allocator = std.heap.FixedBufferAllocator.init(&[_]u8{});
1191	return (self.toType(&allocator.allocator) catch unreachable).hash();
1192	},
1193	.int_type => {
1194	const payload = self.castTag(.int_type).?.data;
1195	var int_payload = Type.Payload.Bits{
1196	.base = .{
1197	.tag = if (payload.signed) .int_signed else .int_unsigned,
1198	},
1199	.data = payload.bits,
1200	};
1201	return Type.initPayload(&int_payload.base).hash();
1202	},
1203		1148
1204	.empty_struct_value,	1149	pub const HashContext = struct {
1205	.empty_array,	1150	ty: Type,
1206	=> {},
1207		1151
1208	.undef,	1152	pub fn hash(self: @This(), v: Value) u64 {
1209	.null_value,	1153	var hasher = std.hash.Wyhash.init(0);
1210	.void_value,
1211	.unreachable_value,
1212	=> std.hash.autoHash(&hasher, self.tag()),
1213		1154
1214	.zero, .bool_false => std.hash.autoHash(&hasher, @as(u64, 0)),	1155	switch (self.ty.zigTypeTag()) {
1215	.one, .bool_true => std.hash.autoHash(&hasher, @as(u64, 1)),	1156	.BoundFn => unreachable, // TODO remove this from the language
1216		1157
1217	.float_16, .float_32, .float_64, .float_128 => {	1158	.Void,
1218	@panic("TODO implement Value.hash for floats");	1159	.NoReturn,
1219	},	1160	.Undefined,
		1161	.Null,
		1162	=> {},
1220		1163
1221	.enum_literal => {	1164	.Type => {
1222	const payload = self.castTag(.enum_literal).?;	1165	var buf: ToTypeBuffer = undefined;
1223	hasher.update(payload.data);	1166	return v.toType(&buf).hash();
1224	},	1167	},
1225	.enum_field_index => {	1168	.Bool => {
1226	const payload = self.castTag(.enum_field_index).?;	1169	std.hash.autoHash(&hasher, v.toBool());
1227	std.hash.autoHash(&hasher, payload.data);	1170	},
1228	},	1171	.Int, .ComptimeInt => {
1229	.bytes => {	1172	var space: BigIntSpace = undefined;
1230	const payload = self.castTag(.bytes).?;	1173	const big = v.toBigInt(&space);
1231	hasher.update(payload.data);
1232	},
1233	.repeated => {
1234	@panic("TODO Value.hash for repeated");
1235	},
1236	.array => {
1237	@panic("TODO Value.hash for array");
1238	},
1239	.slice => {
1240	@panic("TODO Value.hash for slice");
1241	},
1242	.eu_payload_ptr => {
1243	@panic("TODO Value.hash for eu_payload_ptr");
1244	},
1245	.int_u64 => {
1246	const payload = self.castTag(.int_u64).?;
1247	std.hash.autoHash(&hasher, payload.data);
1248	},
1249	.int_i64 => {
1250	const payload = self.castTag(.int_i64).?;
1251	std.hash.autoHash(&hasher, payload.data);
1252	},
1253	.comptime_alloc => {
1254	const payload = self.castTag(.comptime_alloc).?;
1255	std.hash.autoHash(&hasher, payload.data.val.hash());
1256	},
1257	.int_big_positive, .int_big_negative => {
1258	var space: BigIntSpace = undefined;
1259	const big = self.toBigInt(&space);
1260	if (big.limbs.len == 1) {
1261	// handle like {u,i}64 to ensure same hash as with Int{i,u}64
1262	if (big.positive) {
1263	std.hash.autoHash(&hasher, @as(u64, big.limbs[0]));
1264	} else {
1265	std.hash.autoHash(&hasher, @as(u64, @bitCast(usize, -@bitCast(isize, big.limbs[0]))));
1266	}
1267	} else {
1268	std.hash.autoHash(&hasher, big.positive);	1174	std.hash.autoHash(&hasher, big.positive);
1269	for (big.limbs) \|limb\| {	1175	for (big.limbs) \|limb\| {
1270	std.hash.autoHash(&hasher, limb);	1176	std.hash.autoHash(&hasher, limb);
1271	}	1177	}
1272	}	1178	},
1273	},	1179	.Float, .ComptimeFloat => {
1274	.elem_ptr => {	1180	@panic("TODO implement hashing float values");
1275	const payload = self.castTag(.elem_ptr).?.data;	1181	},
1276	std.hash.autoHash(&hasher, payload.array_ptr.hash());	1182	.Pointer => {
1277	std.hash.autoHash(&hasher, payload.index);	1183	@panic("TODO implement hashing pointer values");
1278	},	1184	},
1279	.field_ptr => {	1185	.Array, .Vector => {
1280	const payload = self.castTag(.field_ptr).?.data;	1186	@panic("TODO implement hashing array/vector values");
1281	std.hash.autoHash(&hasher, payload.container_ptr.hash());	1187	},
1282	std.hash.autoHash(&hasher, payload.field_index);	1188	.Struct => {
1283	},	1189	@panic("TODO implement hashing struct values");
1284	.decl_ref => {	1190	},
1285	const decl = self.castTag(.decl_ref).?.data;	1191	.Optional => {
1286	std.hash.autoHash(&hasher, decl);	1192	@panic("TODO implement hashing optional values");
1287	},	1193	},
1288	.function => {	1194	.ErrorUnion => {
1289	const func = self.castTag(.function).?.data;	1195	@panic("TODO implement hashing error union values");
1290	std.hash.autoHash(&hasher, func);	1196	},
1291	},	1197	.ErrorSet => {
1292	.extern_fn => {	1198	@panic("TODO implement hashing error set values");
1293	const decl = self.castTag(.extern_fn).?.data;	1199	},
1294	std.hash.autoHash(&hasher, decl);	1200	.Enum => {
1295	},	1201	@panic("TODO implement hashing enum values");
1296	.variable => {	1202	},
1297	const variable = self.castTag(.variable).?.data;	1203	.Union => {
1298	std.hash.autoHash(&hasher, variable);	1204	@panic("TODO implement hashing union values");
1299	},	1205	},
1300	.@"error" => {	1206	.Fn => {
1301	const payload = self.castTag(.@"error").?.data;	1207	@panic("TODO implement hashing function values");
1302	hasher.update(payload.name);	1208	},
1303	},	1209	.Opaque => {
1304	.error_union => {	1210	@panic("TODO implement hashing opaque values");
1305	const payload = self.castTag(.error_union).?.data;	1211	},
1306	std.hash.autoHash(&hasher, payload.hash());	1212	.Frame => {
1307	},	1213	@panic("TODO implement hashing frame values");
1308	.inferred_alloc => unreachable,	1214	},
1309		1215	.AnyFrame => {
1310	.manyptr_u8_type,	1216	@panic("TODO implement hashing anyframe values");
1311	.manyptr_const_u8_type,	1217	},
1312	.atomic_ordering_type,	1218	.EnumLiteral => {
1313	.atomic_rmw_op_type,	1219	@panic("TODO implement hashing enum literal values");
1314	.calling_convention_type,	1220	},
1315	.float_mode_type,	1221	}
1316	.reduce_op_type,	1222	return hasher.final();
1317	.call_options_type,
1318	.export_options_type,
1319	.extern_options_type,
1320	.@"struct",
1321	.@"union",
1322	=> @panic("TODO this hash function looks pretty broken. audit it"),
1323	}	1223	}
1324	return hasher.final();
1325	}
1326		1224
1327	pub const ArrayHashContext = struct {
1328	pub fn hash(self: @This(), v: Value) u32 {
1329	_ = self;
1330	return v.hash_u32();
1331	}
1332	pub fn eql(self: @This(), a: Value, b: Value) bool {
1333	_ = self;
1334	return a.eql(b);
1335	}
1336	};
1337	pub const HashContext = struct {
1338	pub fn hash(self: @This(), v: Value) u64 {
1339	_ = self;
1340	return v.hash();
1341	}
1342	pub fn eql(self: @This(), a: Value, b: Value) bool {	1225	pub fn eql(self: @This(), a: Value, b: Value) bool {
1343	_ = self;	1226	return a.eql(b, self.ty);
1344	return a.eql(b);
1345	}	1227	}
1346	};	1228	};
1347		1229
...	@@ -1508,111 +1390,6 @@ pub const Value = extern union {	...	@@ -1508,111 +1390,6 @@ pub const Value = extern union {
1508	};	1390	};
1509	}	1391	}
1510		1392
1511	/// Valid for all types. Asserts the value is not undefined.
1512	/// TODO this function is a code smell and should be deleted
1513	fn isType(self: Value) bool {
1514	return switch (self.tag()) {
1515	.ty,
1516	.int_type,
1517	.u1_type,
1518	.u8_type,
1519	.i8_type,
1520	.u16_type,
1521	.i16_type,
1522	.u32_type,
1523	.i32_type,
1524	.u64_type,
1525	.i64_type,
1526	.u128_type,
1527	.i128_type,
1528	.usize_type,
1529	.isize_type,
1530	.c_short_type,
1531	.c_ushort_type,
1532	.c_int_type,
1533	.c_uint_type,
1534	.c_long_type,
1535	.c_ulong_type,
1536	.c_longlong_type,
1537	.c_ulonglong_type,
1538	.c_longdouble_type,
1539	.f16_type,
1540	.f32_type,
1541	.f64_type,
1542	.f128_type,
1543	.c_void_type,
1544	.bool_type,
1545	.void_type,
1546	.type_type,
1547	.anyerror_type,
1548	.comptime_int_type,
1549	.comptime_float_type,
1550	.noreturn_type,
1551	.null_type,
1552	.undefined_type,
1553	.fn_noreturn_no_args_type,
1554	.fn_void_no_args_type,
1555	.fn_naked_noreturn_no_args_type,
1556	.fn_ccc_void_no_args_type,
1557	.single_const_pointer_to_comptime_int_type,
1558	.anyframe_type,
1559	.const_slice_u8_type,
1560	.enum_literal_type,
1561	.manyptr_u8_type,
1562	.manyptr_const_u8_type,
1563	.atomic_ordering_type,
1564	.atomic_rmw_op_type,
1565	.calling_convention_type,
1566	.float_mode_type,
1567	.reduce_op_type,
1568	.call_options_type,
1569	.export_options_type,
1570	.extern_options_type,
1571	=> true,
1572
1573	.zero,
1574	.one,
1575	.empty_array,
1576	.bool_true,
1577	.bool_false,
1578	.function,
1579	.extern_fn,
1580	.variable,
1581	.int_u64,
1582	.int_i64,
1583	.int_big_positive,
1584	.int_big_negative,
1585	.comptime_alloc,
1586	.decl_ref,
1587	.elem_ptr,
1588	.field_ptr,
1589	.bytes,
1590	.repeated,
1591	.array,
1592	.slice,
1593	.float_16,
1594	.float_32,
1595	.float_64,
1596	.float_128,
1597	.void_value,
1598	.enum_literal,
1599	.enum_field_index,
1600	.@"error",
1601	.error_union,
1602	.empty_struct_value,
1603	.@"struct",
1604	.@"union",
1605	.null_value,
1606	.abi_align_default,
1607	.eu_payload_ptr,
1608	=> false,
1609
1610	.undef => unreachable,
1611	.unreachable_value => unreachable,
1612	.inferred_alloc => unreachable,
1613	};
1614	}
1615
1616	/// This type is not copyable since it may contain pointers to its inner data.	1393	/// This type is not copyable since it may contain pointers to its inner data.
1617	pub const Payload = struct {	1394	pub const Payload = struct {
1618	tag: Tag,	1395	tag: Tag,
...	@@ -1806,27 +1583,3 @@ pub const Value = extern union {	...	@@ -1806,27 +1583,3 @@ pub const Value = extern union {
1806	limbs: [(@sizeOf(u64) / @sizeOf(std.math.big.Limb)) + 1]std.math.big.Limb,	1583	limbs: [(@sizeOf(u64) / @sizeOf(std.math.big.Limb)) + 1]std.math.big.Limb,
1807	};	1584	};
1808	};	1585	};
1809
1810	test "hash same value different representation" {
1811	const zero_1 = Value.initTag(.zero);
1812	var payload_1 = Value.Payload.U64{
1813	.base = .{ .tag = .int_u64 },
1814	.data = 0,
1815	};
1816	const zero_2 = Value.initPayload(&payload_1.base);
1817	try std.testing.expectEqual(zero_1.hash(), zero_2.hash());
1818
1819	var payload_2 = Value.Payload.I64{
1820	.base = .{ .tag = .int_i64 },
1821	.data = 0,
1822	};
1823	const zero_3 = Value.initPayload(&payload_2.base);
1824	try std.testing.expectEqual(zero_2.hash(), zero_3.hash());
1825
1826	var payload_3 = Value.Payload.BigInt{
1827	.base = .{ .tag = .int_big_negative },
1828	.data = &[_]std.math.big.Limb{0},
1829	};
1830	const zero_4 = Value.initPayload(&payload_3.base);
1831	try std.testing.expectEqual(zero_3.hash(), zero_4.hash());
1832	}