std: update `std.builtin.Type` fields to follow naming conventions

The compiler actually doesn't need any functional changes for this: Sema
does reification based on the tag indices of `std.builtin.Type` already!
So, no zig1.wasm update is necessary.

This change is necessary to disallow name clashes between fields and
decls on a type, which is a prerequisite of #9938.

1 files changed, 12 insertions, 12 deletions

diff --git a/src/mutable_value.zig b/src/mutable_value.zig
index 9fcac259df..49826c2fb2 100644
--- a/src/mutable_value.zig
+++ b/src/mutable_value.zig
@@ -210,19 +210,19 @@ pub const MutableValue = union(enum) {
                     },
                 },
                 .undef => |ty_ip| switch (Type.fromInterned(ty_ip).zigTypeTag(zcu)) {
-                    .Struct, .Array, .Vector => |type_tag| {
+                    .@"struct", .array, .vector => |type_tag| {
                         const ty = Type.fromInterned(ty_ip);
                         const opt_sent = ty.sentinel(zcu);
-                        if (type_tag == .Struct or opt_sent != null or !allow_repeated) {
+                        if (type_tag == .@"struct" or opt_sent != null or !allow_repeated) {
                             const len_no_sent = ip.aggregateTypeLen(ty_ip);
                             const elems = try arena.alloc(MutableValue, @intCast(len_no_sent + @intFromBool(opt_sent != null)));
                             switch (type_tag) {
-                                .Array, .Vector => {
+                                .array, .vector => {
                                     const elem_ty = ip.childType(ty_ip);
                                     const undef_elem = try pt.intern(.{ .undef = elem_ty });
                                     @memset(elems[0..@intCast(len_no_sent)], .{ .interned = undef_elem });
                                 },
-                                .Struct => for (elems[0..@intCast(len_no_sent)], 0..) |*mut_elem, i| {
+                                .@"struct" => for (elems[0..@intCast(len_no_sent)], 0..) |*mut_elem, i| {
                                     const field_ty = ty.fieldType(i, zcu).toIntern();
                                     mut_elem.* = .{ .interned = try pt.intern(.{ .undef = field_ty }) };
                                 },
@@ -244,7 +244,7 @@ pub const MutableValue = union(enum) {
                             } };
                         }
                     },
-                    .Union => {
+                    .@"union" => {
                         const payload = try arena.create(MutableValue);
                         const backing_ty = try Type.fromInterned(ty_ip).unionBackingType(pt);
                         payload.* = .{ .interned = try pt.intern(.{ .undef = backing_ty.toIntern() }) };
@@ -254,7 +254,7 @@ pub const MutableValue = union(enum) {
                             .payload = payload,
                         } };
                     },
-                    .Pointer => {
+                    .pointer => {
                         const ptr_ty = ip.indexToKey(ty_ip).ptr_type;
                         if (ptr_ty.flags.size != .Slice) return;
                         const ptr = try arena.create(MutableValue);
@@ -375,7 +375,7 @@ pub const MutableValue = union(enum) {
                 if (field_val.eqlTrivial(r.child.*)) return;
                 // We must switch to either the `aggregate` or the `bytes` representation.
                 const len_inc_sent = ip.aggregateTypeLenIncludingSentinel(r.ty);
-                if (Type.fromInterned(r.ty).zigTypeTag(zcu) != .Struct and
+                if (Type.fromInterned(r.ty).zigTypeTag(zcu) != .@"struct" and
                     is_trivial_int and
                     Type.fromInterned(r.ty).childType(zcu).toIntern() == .u8_type and
                     r.child.isTrivialInt(zcu))
@@ -402,7 +402,7 @@ pub const MutableValue = union(enum) {
             },
             .aggregate => |a| {
                 a.elems[field_idx] = field_val;
-                const is_struct = Type.fromInterned(a.ty).zigTypeTag(zcu) == .Struct;
+                const is_struct = Type.fromInterned(a.ty).zigTypeTag(zcu) == .@"struct";
                 // Attempt to switch to a more efficient representation.
                 const is_repeated = for (a.elems) |e| {
                     if (!e.eqlTrivial(field_val)) break false;
@@ -457,9 +457,9 @@ pub const MutableValue = union(enum) {
             .interned => |ip_index| {
                 const ty = Type.fromInterned(pt.zcu.intern_pool.typeOf(ip_index));
                 switch (ty.zigTypeTag(pt.zcu)) {
-                    .Array, .Vector => return .{ .interned = (try Value.fromInterned(ip_index).elemValue(pt, field_idx)).toIntern() },
-                    .Struct, .Union => return .{ .interned = (try Value.fromInterned(ip_index).fieldValue(pt, field_idx)).toIntern() },
-                    .Pointer => {
+                    .array, .vector => return .{ .interned = (try Value.fromInterned(ip_index).elemValue(pt, field_idx)).toIntern() },
+                    .@"struct", .@"union" => return .{ .interned = (try Value.fromInterned(ip_index).fieldValue(pt, field_idx)).toIntern() },
+                    .pointer => {
                         assert(ty.isSlice(pt.zcu));
                         return switch (field_idx) {
                             Value.slice_ptr_index => .{ .interned = Value.fromInterned(ip_index).slicePtr(pt.zcu).toIntern() },
@@ -551,7 +551,7 @@ pub const MutableValue = union(enum) {
     /// Used for deciding when to switch aggregate representations without fully
     /// interning many values.
     fn eqlTrivial(a: MutableValue, b: MutableValue) bool {
-        const Tag = @typeInfo(MutableValue).Union.tag_type.?;
+        const Tag = @typeInfo(MutableValue).@"union".tag_type.?;
         if (@as(Tag, a) != @as(Tag, b)) return false;
         return switch (a) {
             .interned => |a_ip| a_ip == b.interned,